IBM Full Stack Software Developer key terms

A tracked project history made of commits, branches, and tags, usually stored locally with a remote copy on a hosting service. It records what changed, who changed it, and when.

A saved snapshot of staged changes in Git, identified by a hash and linked to its parent commit. Each commit carries an author, timestamp, and message describing the change.

A movable pointer to a line of commits in Git, letting developers isolate work such as a feature or fix. Branches are cheap to create and are typically merged back into a main line.

A situation where Git cannot automatically combine changes because two branches modified the same lines or file regions. A developer must edit the file to resolve it before completing the merge.

A hosted-repository request to review and merge one branch into another. It supports code review comments, automated checks, and discussion before the change is accepted.

An iterative approach that delivers software in small increments with frequent feedback and adaptive planning. Work is organized into short cycles, and requirements are expected to change.

A short, plain-language statement of a feature from the end user's perspective, often phrased as a role, a goal, and a benefit. It is refined into tasks and acceptance criteria before implementation.

A fixed-length iteration, commonly one to four weeks, in which a team commits to a set of work and produces a potentially releasable increment. Scope is protected during the sprint.

An automated test that exercises a single function, class, or module in isolation, usually with dependencies replaced by test doubles. It runs fast and pinpoints the location of a defect.

A practice of writing a failing test first, then the minimum code to pass it, then refactoring. It keeps tests focused on behavior and produces a regression suite as a side effect.

Restructuring existing code to improve readability or design without changing its observable behavior. It is normally protected by automated tests that confirm behavior is preserved.

The accumulated cost of shortcuts in design or code that make future changes slower or riskier. Like financial debt, it accrues interest until it is deliberately paid down.

An HTTP interface organized around resources identified by URLs and manipulated with standard methods such as GET, POST, PUT, and DELETE. Responses are typically JSON and should be stateless.

A three-digit number in an HTTP response that summarizes the outcome, grouped as 2xx success, 3xx redirection, 4xx client error, and 5xx server error. Clients and tests branch on these values.

A lightweight text format for structured data using objects, arrays, strings, numbers, booleans, and null. It is the default payload format for most web APIs and browser fetches.

The browser's in-memory tree representation of an HTML document, which scripts can read and modify. Updating the DOM changes what the user sees without a full page reload.

An in-memory copy of the UI tree that a library such as React compares against the previous version to compute minimal real DOM updates. It makes declarative rendering practical.

A reusable, self-contained unit of UI written as a function or class that returns elements from props and state. Components compose into pages and re-render when their data changes.

Read-only data passed from a parent React component into a child component. Changing props from above triggers a re-render, but a component must not modify its own props.

Data a component owns and can change over time, such as form input or fetched results. Updating state schedules a re-render reflecting the new value.

A function registered to run when a specific browser event, such as a click or keypress, occurs on an element. Listeners make pages interactive and can be added or removed dynamically.

A browser security mechanism that blocks cross-origin requests unless the server returns headers permitting the requesting origin. It protects users from unauthorized reads across sites.

A layout approach using flexible grids, relative units, and media queries so a page adapts to different screen sizes. It avoids maintaining separate sites for mobile and desktop.

The rule that every rendered element occupies a content box surrounded by padding, border, and margin. Understanding it is essential for predicting element size and spacing.

A JavaScript runtime built on the V8 engine that runs code outside the browser, commonly for web servers and tooling. It uses an event loop and non-blocking I/O for high concurrency.

A minimalist Node.js web framework providing routing, middleware, and request/response helpers. Middleware functions run in order and can end a request or pass control onward.

A function in a request pipeline that can inspect or modify the request and response, then either end the cycle or call the next function. It commonly handles logging, auth, and parsing.

The default package manager for Node.js, used to install dependencies, run scripts, and publish packages. A project's dependencies and versions are recorded in package.json and the lockfile.

An external library or package a project relies on at build or runtime. Versions are pinned in a manifest and lockfile so installs are reproducible across environments.

A style where long-running work such as I/O does not block the main thread; results arrive later via callbacks, promises, or async/await. It is central to Node.js scalability.

An object representing the eventual result of an asynchronous operation, which settles once as fulfilled or rejected. Promises can be chained and awaited, replacing nested callbacks.

A database storing data in tables of rows and columns with defined relationships and constraints, queried with SQL. Transactions and foreign keys help keep data consistent.

A declarative language for querying and modifying relational data using statements such as SELECT, INSERT, UPDATE, and DELETE. It also defines schemas and controls access.

A library that maps application objects to database tables so developers write code instead of raw SQL. It reduces boilerplate but can hide inefficient queries.

The process of verifying who a user claims to be, typically with credentials, tokens, or federated identity. It answers identity questions, while authorization decides what that identity may do.

The process of deciding which actions or resources an authenticated identity is permitted to access. It is enforced server-side, often through roles, scopes, or policies.

A signed, URL-safe token carrying claims about a subject, commonly used to carry identity between a client and API. The server verifies the signature rather than storing session state.

A read-only template built from layered instructions that packages an application with its dependencies and runtime. Containers are created from images and share the host kernel.

An isolated process with its own filesystem view and resource limits, sharing the host operating system kernel. Containers start quickly and behave consistently across environments.

A text file of instructions that builds a Docker image, such as choosing a base image, copying files, and setting the start command. Layer order affects build caching.

A service that stores and distributes container images by tag, such as Docker Hub or a private registry. Deployments pull images from it by name and version.

An orchestration platform that schedules containers across a cluster, restarts failed ones, and scales replicas. It also provides service discovery, configuration, and rolling updates.

The smallest deployable unit in Kubernetes, wrapping one or more tightly coupled containers that share networking and storage. Pods are ephemeral and replaced rather than repaired in place.

A practice where developers merge frequently and each change triggers automated build and test runs. Failures surface early, keeping the main branch releasable.

An extension of continuous integration where every passing build is automatically prepared for release, with deployment to production requiring a manual approval.

An automated sequence of stages, such as build, test, scan, and deploy, that runs when code changes. Pipelines make releases repeatable and reduce manual error.

Managing servers, networks, and cloud resources through versioned definition files rather than manual console changes. It makes environments reproducible, reviewable, and easier to roll back.

Renting computing resources such as servers, storage, and databases over a network on demand, paying for what is used. Providers manage the underlying hardware and offer elasticity.

An architecture splitting an application into small independently deployable services that communicate over a network. Each service owns its data and can scale and release separately.