Software Development Glossary

Access control model founded on attributes of the requester, the resource and the context.

Convention defining how compiled code interacts at the binary level: calls, data, symbols and other rules.

Set of transactional properties: atomicity, consistency, isolation and durability.

Note documenting a design decision, its context, options and consequences.

Translation of code before execution, as opposed to just-in-time compilation.

Contract exposing functions, operations or data usable by other software; an API is not necessarily accessible over a network.

Description of the exposed operations, parameters, responses, errors and conditions of use of an interface.

Set of attributes describing accessible roles and states when native HTML mechanisms are not enough.

Class designed to serve as a base and may include operations without a complete implementation.

Representation that exposes the necessary aspects while hiding implementation details.

Verifiable condition used to determine that a feature meets its need.

Conformance check against criteria allowing a stakeholder to accept a feature.

Set of rules and checks governing the use of protected resources.

Element presented to an API to exercise granted permissions, with a defined scope and lifetime.

Pattern that translates one interface into another expected by the consuming code.

Coherent group of domain objects treated as a unit of consistency around a root.

Approach favouring adaptation, collaboration and iterative deliveries, without imposing a single method.

Triggering a notification when an important operational condition is detected.

Finite and precise sequence of steps intended to solve a problem or perform a computation.

Average cost per operation over a sequence of operations, without necessarily assuming a random distribution.

Tools and APIs that allow creating, compiling, testing and distributing Android applications.

Structured web framework offering notably dependency injection, components and integrated tooling.

Function defined without a declared name, often used locally or passed as a value.

Configuration and deployment automation tool, often based on inventories and playbooks.

Recurring solution likely to create more problems than it solves in a given context.

Format distributing a Linux application in a self-contained executable file, subject to its dependencies and constraints.

Software designed to deliver a service to a user or to another system.

Distribution control and validation procedure imposed or offered by certain platforms, notably Apple.

Authorizations granted to a software to access protected functions or data.

Environment that restricts a program's access to system resources and capabilities.

Set of measures that aim to protect a software and its data against unauthorized uses or accesses.

Value or expression actually supplied to a function when it is called.

Operator performing a numerical calculation, such as addition or division.

Structure providing access to several elements, often by index; its size and homogeneity vary.

Low-level language representing machine instructions through mnemonics and symbols.

Check of a programming assumption that may trigger a failure signal; it does not replace validation of untrusted data.

Operation that gives a value to a variable, field or location.

Syntactic constructs marking asynchronous functions and wait points in several languages.

Model that allows a task to suspend its wait for an operation while other work progresses.

Set of accessible points through which a system can be probed or compromised.

Data or property attached to an object or class.

Verification of the identity claimed by a user, service or other actor.

Determination of the actions that a recognized identity is allowed to perform.

Verification that can be executed repeatedly by a tool and produces an actionable result.

Mechanism that checks, downloads and installs new versions according to a defined policy.

Automatic adjustment of resources or instance count according to metrics or rules.

Approach that describes and verifies observable behaviour from shared examples.

Part that performs server-side processing, data access and other services behind an interface.

Ordered and evolving list of work considered or selected for a product or team.

Mechanism that makes a producer slow down when the consumer can no longer keep up.

Exploration of candidate solutions by abandoning a branch when it no longer fits.

Procedures for preserving and recovering data and configuration after an incident.

Ability of a new version to accept the usages or data of an earlier version; exact guarantees depend on the contract.

Situation that stops recursive calls and prevents infinite recursion.

Shell and scripting language used to launch commands and automate tasks on compatible systems.

Grouping several operations to reduce fixed processing or communication costs.

Comparative performance measurement under reproducible and documented conditions.

Input or situation leading to the most favourable cost for a given size.

Asymptotic upper bound on growth, often used to express algorithmic cost.

Asymptotic lower bound of a cost or growth function.

Asymptotic bound that is both upper and lower of a function.

Near-complete tree generally stored in an array and locally ordered by priority.

Search that repeatedly halves an ordered domain to reduce the possibilities.

Tree whose nodes respect an order relation that facilitates searches and updates.

Tree in which each node has at most two children.

Search for the revision responsible for a defect by progressively testing points in history.

Strategy alternating two complete environments to switch traffic and facilitate rollback.

Logical type representing two values, generally true and false.

Temporary access to a value without transferring ownership, governed by the language's rules.

Resource or step that limits the overall performance of a process.

Boundary within which a model and business vocabulary retain a coherent meaning.

Change in execution path based on a condition or destination.

Proportion of decision outcomes executed by tests according to the measuring tool.

Exploring a graph level by level using a queue.

Statement that exits a loop or other selectable construct according to the language's rules.

Location or condition that suspends the program in a debugger.

Temporary area storing data during its production, transformation or transmission.

Software defect causing a gap between the actual behaviour and the expected one.

Ability to trigger a defect in a controlled way with known steps and conditions.

Process transforming sources, dependencies and resources into usable or distributable artefacts.

File produced by a build, such as an executable, library, archive or container image.

System, architecture and environment for which an artefact is built.

Tool that analyzes and bundles or transforms a project's resources in order to prepare them for distribution.

Intermediate representation of instructions intended for a virtual machine or execution engine.

General-purpose language close to machine representations, used among other things for systems and libraries.

Multiparadigm language in the .NET ecosystem used notably for applications, services and games.

General-purpose language derived from C, combining low-level programming, objects, generics and abstractions.

Theoretical result on the trade-offs of a distributed system facing a network partition between linearizable consistency and availability of responses.

Practice that keeps the software ready to be released thanks to a validation and preparation pipeline.

Network of servers distributing resources from points close to users or suited to the traffic.

Practice of integrating changes frequently with automated checks, often triggered by commits.

Automated sequence of steps such as testing, building, verification and delivery.

Interface driven by entering textual commands and arguments.

System that generates build files for various tools and environments, notably for C and C++.

Statement that validates the changes of a transaction.

Browser mechanism governing JavaScript access to responses from other origins; it is not an authentication mechanism.

Measure of processor usage or demand, to be contextualized with respect to the number of cores.

Attack that makes the victim's authenticated browser send an unwanted action to a site.

Style sheet language defining the presentation, layout and visual adaptation of a document.

CSS layout model based on coordinated rows and columns.

Mechanism combining origins, layers, importance, specificity and order to choose the applied styles.

Expression identifying the elements to which a style rule applies.

Priority rule used to break ties between competing CSS declarations.

Public identifier for a vulnerability listed in the Common Vulnerabilities and Exposures program.

Framework for measuring the technical severity of a vulnerability; the score does not replace context analysis.

Temporary retention of results or data to avoid a more costly operation.

Access for which the requested data is found in the cache.

Removing or replacing cached data when its validity ends or the source changes.

Access for which the data is absent from the cache and must be retrieved or recomputed.

Function handed to a component that will call it on an event or operation.

Progressive rollout of a version to a fraction of traffic or users before generalizing it.

Official package manager and build tool of the Rust ecosystem.

Document tracing the notable changes of a product between its versions.

Textual unit; Unicode code point, code unit and perceived character do not always coincide.

Applying the changes of a selected commit onto the current branch, generally creating a new commit.

Process created or launched by another process, with management links dependent on the system.

Mechanism that temporarily interrupts calls to a failing service to limit cascading failures.

Definition used to build objects and to describe their attributes, methods or contracts.

Family of principles that give the domain and use cases inward-pointing dependencies.

Model in which a client requests services from a server via a communication mechanism.

Significant generation of the interface in the browser using JavaScript.

Function that retains access to some bindings of its lexical context after that context has exited.

Group of statements delimited by the language's syntax or by indentation.

Measure of the portions of code exercised by tests, which does not guarantee their ability to detect bugs.

Explanations describing the use, contracts or implementation decisions of a component.

Tool that automatically applies a standardized presentation to source code.

Set of contextualized properties such as correctness, readability, reliability, security and maintainability.

Examination of changes by others to identify defects and improve their maintainability.

Cryptographic signature linking an artefact to a publishing identity and allowing verification of its integrity.

Splitting code into separately loadable chunks to reduce certain loading costs.

Implicit conversion imposed by a language's rules during an operation.

Degree of closeness of the responsibilities gathered within a module.

Attribute of a table defined by a name, a type and possibly constraints.

Text in code intended for readers or tools, generally ignored during execution.

Git object recording a snapshot and metadata, notably parent(s), author and message.

Fingerprint identifying a commit object in the repository; its length and algorithm can depend on the Git format.

Operator that evaluates a relation, such as equality, order or identity depending on the language.

Problem that prevents a compiler from producing the requested artefact normally.

Tool that translates a source language into another representation, often machine code or an intermediate language.

Index built on multiple columns, whose order can influence how queries use it.

Statement grouping several statements under a common structure, such as a conditional block.

Organization of multiple tasks whose execution periods overlap, even on a single core.

Property of an operation perceived as indivisible by other participants according to a given model.

Expression whose result drives an execution choice.

Set of reusable connections that avoid repeating costly creations.

Value or binding presented as non-reassignable; this does not always imply immutability of the referenced objects.

Mechanism involved in the creation or initialization of an object.

Set of layers and metadata serving as an immutable reference template for creating containers.

Coordination of deployment, resources, networking and recovery of multiple containers.

Mechanism that retains or shares data beyond the lifecycle of a given container.

Header indicating the media type of a content and optionally its character set.

Object or construct that frames the acquisition and release of resources, such as an open file.

Statement that proceeds to the next iteration of a loop without executing the rest of the current iteration.

Automated rollout to production of each change satisfying the defined checks, without systematic manual validation.

Modification, correction, documentation or other work proposed to a project, under its collaboration rules.

Approach that provides consistent default behaviours to reduce explicit configuration.

Small piece of data associated with a domain and transmitted according to browser rules, often used for sessions.

Coordinated process for reporting and publishing a vulnerability to facilitate its remediation.

Capture of part of a process's memory and processor state after an incident, potentially sensitive.

Unit of computation that can suspend and resume its execution while preserving its state.

Value linking several traces or operations belonging to the same request path.

Degree of dependency between software elements; high coupling often makes changes more difficult.

Unexpected stop of a program, process or component.

Portion of code that manipulates shared state requiring a coordinated access protocol.

Producing a program for a platform different from the one performing the compilation.

Application designed to run on several systems from a partially or largely shared codebase.

Function producing a fixed-length fingerprint designed to resist certain searches and collisions.

Unique random value added before hashing a password in order to counter precomputed tables in particular.

Conceptual transformation of a function with several arguments into a succession of single-argument functions.

Pagination using an opaque or explicit marker rather than a simple page number, suited to certain evolving streams.

Dynamic analysis of a running application by exercising it to detect certain vulnerabilities.

Software that manages the storage, queries, security and integrity of one or more databases.

Approach that structures software around business concepts and a shared language with domain experts.

SQL statement that removes rows; without an appropriate filter it can target all rows.

HTTP method requesting the deletion of the targeted resource, with an expected idempotent semantics.

Programmable tree representation of a document used by browsers and scripts.

Principle that invites avoiding duplication of knowledge or rules rather than any textual repetition.

Structure intended to carry data between layers or services without necessarily carrying business logic.

Process that provides services without a main user interface, according to the system's conventions.

Unsynchronized concurrent accesses to the same memory, with at least one write, according to a precise memory model.

Processing elements as they arrive rather than after a full load.

Set of possible values together with the operations and constraints associated with them.

Organized set of data designed to be stored, queried and modified according to defined rules.

Recoverable copy of data and optionally of logs allowing restoration after an incident.

Auxiliary structure that accelerates certain searches and sorts at the cost of space and update overhead.

Versioned change to the schema or data accompanying the evolution of an application.

Definition of the structure, relations, types and constraints of the data.

Situation in which tasks wait indefinitely for resources or events held by other waiters.

Technique that waits for a period without a new event before triggering processing.

Tool allowing inspection of a program's state, setting breakpoints and controlling its execution.

Process of identifying, explaining and fixing a program defect.

Introduction of a name and possibly its type, scope or properties.

Approach that expresses the desired result or constraints rather than an explicit sequence of operations.

Decreasing a value, usually by one unit.

Recursive copy of sub-objects according to defined rules, aiming to limit unintended sharing.

Shared criteria determining that work is considered finished at the agreed quality level.

Deliberate introduction of redundancies to improve certain uses, notably reads, with synchronization costs.

External component whose use a project requires in order to function.

Supplying required components from the outside rather than creating them directly within the consumer.

Principle stating that high-level and low-level modules depend on suitable abstractions.

Computing a set of versions that satisfies the declared compatibility constraints.

Installation or provisioning of a software version in a target environment.

Return to an earlier version or a known working state, sometimes complex if data has changed.

Signal that a feature is still available for now but is no longer recommended and may be removed.

Exploration following a branch as far as possible before backtracking.

Reconstruction of a structure from a serialized representation; this operation must be secured for dangerous formats.

Reusable general solution to a recurring design problem, to be adapted rather than copied mechanically.

Program intended primarily for personal computers and their operating systems.

Finalization mechanism provided by some languages; its moment of execution may be uncertain.

Test designed to yield the same results under identical initial conditions.

Set of practices bringing development and operations closer together to improve delivery, reliability and operational feedback.

Configuration used to create and experiment with the software before validation.

Work cycle leading to a new version or to exploitable learning.

Structure mapping keys to values in order to perform key-based lookups.

Cryptographic proof of integrity and origin linked to a private key, verifiable with the corresponding public key.

Package explicitly required by a project for its compilation or operation.

Set of measures allowing services to be restored after a major failure.

Process allowing several nodes to agree on a decision despite certain failures.

Representation of an operation across multiple services through connected time segments.

Solving by decomposing a problem into sub-problems then combining their results.

Repetition that executes its body before the continuation check, when the language provides it.

Ecosystem of tools allowing notably building, distributing and running images and containers.

Tool that describes and orchestrates several containerized services with declarative configuration.

File of instructions describing the steps to create a container image.

Lack or obsolescence of documentation that increases the cost of understanding and maintenance.

Domain object identified by a persistent identity rather than by its values alone.

Significant fact that has already occurred in the domain and is communicated to other parts of the system.

Component carrying out a domain operation that does not naturally fit into an entity.

Practice of using an object based on the operations it provides rather than its declared class.

Method that reuses results of overlapping sub-problems to avoid recomputing them.

Language in which the membership of values in types is mainly determined and checked at runtime.

Conventional file containing configuration variables; it can hold secrets and must not be shared without precautions.

Desktop application framework combining notably Chromium and Node.js to distribute web interfaces.

Grouping data and operations behind an interface that controls access to them.

Reversible transformation of data into unreadable content without the appropriate key, under a suitable scheme.

Test running a complete user or technical scenario through the product's main layers.

Address or access point exposing an operation or resource of a service.

Location from which the execution of a program or component starts.

Name-value pair supplied to a process by its execution environment.

Adapting an application's settings according to development, test, staging or production.

Uncertain evaluation of effort, duration or complexity before realization.

Mechanism that dispatches events and resumes tasks via a queue or scheduler.

Organization in which components react to events rather than only to direct calls.

Guarantee that copies converge after writes stop, without identical reads everywhere immediately.

Representation suited to certain decimal calculations, notably financial, subject to defined precision and rules.

Guarantee of a logically unique processing within a defined scope, hard to achieve end-to-end without deduplication or transactions.

Signal of an unusual situation that interrupts the normal flow until it is potentially handled.

Mechanism that allows catching, processing or propagating an exception.

File containing code and information that allow it to be loaded and launched by a compatible system.

Carrying out a program's instructions by a hardware or software environment.

Policy that progressively increases the delay between retries, often with a random component.

Element explicitly exposed by a module to its consumers.

Construct evaluated to produce a value, possibly with side effects.

Structure where the first element added is the first removed.

Construction that centralizes or abstracts the creation of objects.

Simplified but functional implementation of a dependency, for example an in-memory store.

Configuration switch that enables a feature for certain environments or users.

Operation that keeps the elements of a collection that satisfy a predicate.

Block executed when exiting an exception-handling structure according to the language's rules, often used to clean up resources.

Data, objects or environment prepared to provide a reproducible context for tests.

Test whose result varies without a relevant code change, often due to timing or external dependencies.

Format and system for distributing Linux applications using runtimes and sandbox mechanisms.

CSS layout model suited to distributing elements along a main axis and a cross axis.

Approximate numeric representation of a range of real values; it can introduce rounding errors.

Graphical representation of processes and decisions through connected shapes.

Framework for building interfaces compiled for multiple platforms using Dart.

Form of repetition generally based on a counter or on iterating over a collection.

Column or set of columns that links a table to a key of another table or the same table.

Copy of a repository on a platform allowing independent development and possible contributions.

Structure and tools that organize the development of an application and often control part of its flow.

Software whose license notably guarantees the freedoms to use, study, modify and redistribute.

Part of an application that presents an interface and handles interactions on the user side.

Practice covering several layers of an application, notably interface, services and data.

Reusable unit of code that may receive arguments and produce a result or effects.

Statement or expression that triggers the execution of a function with given arguments.

Building a function by chaining the results of several functions.

Description of the calling interface, including, depending on the language, the name, parameters, types and result.

Description of what a system must accomplish to meet a need.

Verification of expected behaviour from the standpoint of its requirements and results.

Abstraction representing a result potentially available later, with modalities specific to each environment.

Automatically submitting many often-unexpected inputs to identify crashes and abnormal behaviour.

HTTP method intended to retrieve a representation without requesting state modification on the server.

SQL clause grouping rows to compute aggregates per group.

Open-source graphical interface toolkit used on Linux and other systems.

Interface using windows, buttons, panels and other interactive visual elements.

Mechanism that automates the recovery of memory that has become unreachable according to its tracking rules.

Source or artefact produced automatically from a definition, schema or other program.

Construct that produces values on demand as traversal progresses rather than building the whole sequence at once.

Definition of structures or functions parameterized by types.

Distributed version control system that organizes history around commits and local or remote references.

Git extension storing large files through pointers tracked by Git and an associated storage backend.

Command placing selected file versions or changes into the index.

Movable reference to a commit allowing several lines of work to evolve.

Command creating a local copy of an existing repository and generally configuring a remote.

Command showing differences between files, the index or commits according to options.

Command retrieving remote objects and references without automatically merging these changes into the working branch.

Rules excluding certain untracked files from the usual listing and automatic adding; they do not remove files already tracked.

Area recording the version of files to include in the next commit.

Command displaying the history of commits and associated information.

Command performing a fetch then an integration, by merge or rebase depending on configuration.

Command transmitting local references and objects to an authorized remote repository.

Command moving a reference or resetting the index and files according to its mode; some uses destroy local changes.

Command creating a new commit that reverses the changes of an earlier commit, subject to possible resolution.

Mechanism temporarily recording modifications of the working tree or index to reapply them later.

Command showing the state of the working tree and index relative to the repository's references.

Repository referenced from another repository at a given revision, with its own synchronization cycle.

Named reference, often used to mark a published version; an annotated tag carries its own metadata.

Platform for hosting and collaboration around Git repositories, distinct from the Git software itself.

Collaboration and software delivery platform around Git repositories, notably offered for self-hosting.

Scenario structure expressing context, action and expected outcome.

Variable defined in a general scope; its use can increase coupling.

Compiled language designed around tool simplicity, concurrency and network services.

Build and automation tool widely used in the JVM and Android ecosystems.

Set of vertices and links modelling relations, which may be directed or undirected.

Query language and API runtime environment that allows clients to select fields precisely.

Method that makes successive local choices, whose global optimality must be justified for the problem.

Remote procedure call framework relying notably on HTTP/2 and Protocol Buffers in its usual operation.

SQL clause filtering groups after grouping, to be distinguished from WHERE applied to rows.

Reference designating the current commit, generally via the active branch.

Markup language describing the structure and semantics of a web page.

Information associated with an element, for example alt, href or lang.

Component of the document defined by a tag or a DOM object, with its semantics and attributes.

Status indicating the request succeeded; the content of the response depends on the method.

Status indicating that one or more resources were created as a result of the request.

Status indicating a successful operation with no response body.

Permanent redirection statuses; 308 preserves the HTTP method during the redirection.

Status indicating the server cannot or will not process a request it considers incorrect.

Status indicating that valid authentication is required or missing, despite its misleading name.

Status indicating that the server understood the request but refuses to authorize it.

Status indicating that the requested resource cannot be found or that the server does not wish to reveal its existence.

Status indicating a conflict with the current state of the resource, for example during a concurrent update.

Status indicating that the client has exceeded a rate limit defined by the server.

Generic status indicating an unexpected malfunction of the server.

Status indicating that a gateway or proxy received an invalid response from an upstream server.

Status indicating temporary unavailability, for example due to overload or maintenance.

Optional part of an HTTP message carrying a representation or data.

Program that builds and sends HTTP requests then processes the responses received.

Metadata field of a request or response, such as Content-Type or Authorization.

Message sent by a client including notably the method, target, headers and optionally a body.

Message from the server containing a status code, headers and optionally a body.

Program that receives HTTP requests and returns responses compliant with the protocol.

Three-digit number describing the outcome of a request, according to five main classes.

Situation where different keys lead to the same location or fingerprint.

Structure that transforms keys into locations to speed up average-case lookups.

Automated check that determines whether an instance is running and can receive traffic.

Memory region used notably for allocations whose lifetime does not simply follow call boundaries.

Kubernetes package manager that uses charts to describe and install resources.

Practical rule that seeks an acceptable solution without always guaranteeing optimality.

Design that isolates the business core from technical interfaces through ports and adapters.

Function that takes a function as an argument or returns a function.

Location where a program allows external or customizable code to run on an event.

Increasing capacity by adding instances or machines.

Update of certain modules or of the interface during development without a full restart, depending on the tool.

Patch published quickly to resolve an important defect in a version in service.

Attaching, on the client side, interactive behaviour to already produced HTML, according to a framework.

SQL statement that adds new rows to a table.

Set of techniques for exchanging between processes: pipes, sockets, shared memory or messages.

Exchange of messages between an embedded web interface and the host application's native code.

Property whereby repeating the same operation produces the same intended final effect as a single execution, aside from possible side effects.

Name used to designate a variable, function, class or other program element.

Construct that executes one block if a condition is satisfied and optionally another block otherwise.

Property preventing modification of a value or object after its creation.

Approach that describes the operations and state changes to be performed.

Making available elements defined in another module or namespace.

Documented review of the course, causes, impacts and improvements after an outage.

Increasing a value, usually by one unit.

Integrated and potentially usable addition of a capability to the existing product.

Initial spacing of lines that aids reading and sometimes participates in the syntax, notably in Python.

Position or access key; in sequences numbering often starts at zero, but not always.

Versioned description of infrastructure resources using files and automation tools.

Mechanism that allows deriving a class or type from another in order to reuse or specialize its behaviour.

Assigning the state or the first usable value of a variable or object.

Join that keeps only combinations of rows that satisfy the matching condition.

Verification that received data respects types, formats and business rules before use.

Sort that progressively builds an ordered portion, efficient notably on small or nearly sorted data.

Program that prepares an application for use on a system by placing its components and settings.

Object created from a particular class or model.

Number with no fractional part, whose size and limits depend on its representation.

Test verifying the real interaction of several components or systems.

Contract describing accessible operations without necessarily imposing their implementation.

Set of values that determine what an interface displays and how it reacts.

Program that evaluates or executes instructions through an interpretation environment; some implementations combine compilation and interpretation.

Degree of separation between concurrent transactions, determining the observable anomalies.

Item recorded in a tracking tool, such as a problem, suggestion or work to be done.

Object that can provide a sequence of elements to be traversed according to a given protocol.

Single pass of a loop, or successive operation over a collection.

Object that holds traversal state and yields successive elements.

Tools and APIs required for developing applications for the relevant Apple devices.

Compilation during execution, often to optimize the most-used portions of code.

Operation combining rows from different sources according to a relation or condition.

Textual data exchange format based on objects, arrays, strings, numbers, booleans and null.

Compact format for transmitting signed or optionally encrypted claims; its content is not secret by default.

Multiparadigm object-oriented language generally compiled to bytecode executed notably on the JVM.

Programming language standardized by ECMAScript, used in browsers and in many server-side environments.

Principle of avoiding unnecessary complexity for the actual need.

Visual flow management method favouring work-in-progress limits and fluidity.

Identifier used to retrieve a value in an associative table or data structure.

Word that is reserved or has a special role in a language's grammar.

Statically typed language interoperable notably with Java and used for Android and the server.

Platform that orchestrates containerized workloads using declarative resources and controllers.

Resource historically describing external HTTP/HTTPS access to services; its controller and evolution depend on the platform.

Smallest deployable Kubernetes unit, containing one or more containers sharing certain resources.

Abstraction providing a stable access point to a changing set of pods.

Structure where the last element added is the first removed.

Software environment that executes bytecode or intermediate code, such as the JVM.

Duration between a request and the observed response or effect.

Organization that separates functions by levels, such as presentation, business logic and data access.

Deferred evaluation of an expression or computation until its result is needed.

Deferring the load of a resource or component until its probable or actual use.

Procedure that selects a node to coordinate actions within a distributed group.

Join that keeps all rows from the left side, even when there is no match on the right.

Existing code whose evolution can be difficult due to its age, dependencies or lack of tests.

Name resolution based on the structure of the source code rather than the dynamic call chain.

Period during which a reference or resource remains valid under the program's guarantees.

Search that scans elements one after another until finding the target or exhausting the collection.

Structure of elements connected by references, facilitating certain insertions at the cost of sequential access.

Tool that combines compiled objects and resolves their symbols to produce a linked artefact.

Tool that signals potential errors, inconsistencies or rule violations in code.

Ordered collection of elements whose properties and performance depend on the implementation.

Direct writing of a value in code, for example 42, true or "hello".

Situation in which tasks remain active and react without making useful progress.

Check designed to detect that a process must be restarted when it no longer makes progress.

Component that distributes requests across several instances according to a strategy.

Trial measuring a system's behaviour under a representative or expected level of load.

Component that loads an executable and its dependencies into memory before it starts.

Transformation of data stored on the device to make it compatible with a new version.

Copy of the repository present on a machine, with its objects, references and working state.

Variable accessible within a limited scope, typically a function or block.

Operation from an algorithm guaranteeing that at least one participant makes progress despite contention, without individual guarantees.

File recording the resolved versions to facilitate installation reproducibility.

Category of severity or detail, such as debug, info, warning or error.

Structured or textual production of event traces during execution.

Defect of reasoning or logic producing an incorrect result despite possible execution.

Operator that combines or inverts conditions, such as AND, OR or NOT.

Construct that repeats statements while a condition or sequence provides for it.

Property that remains true before and after each iteration and helps prove correctness.

Pattern separating data and application logic, presentation and interaction handling.

Version limited enough to test essential hypotheses with real users.

Pattern in which a presentation model links state and interface, often using data-binding mechanisms.

Binary instructions specific to a processor architecture and executable by it.

Naming convention for a central line of development; Git does not impose this name.

Ease of understanding, correcting and evolving a software at controlled cost.

Person or group responsible for the evolution, review of contributions and often the releases of a project.

Tool that automates build tasks according to dependency rules and targets.

File describing a project's identity, configuration, scripts and dependencies.

Model in which the programmer explicitly controls allocations and releases.

Verification performed directly by a person without full automated execution of the scenario.

Operation that applies a transformation to each element of a collection.

Language that structures content using markers; HTML describes documents and is not, on its own, a general-purpose programming language.

Stored physical result of a query, refreshed according to a defined strategy.

Build and dependency management tool based notably on an XML project model for the JVM.

CSS condition applying styles based on characteristics of the medium or environment.

Caching results of calls to avoid recomputation with the same inputs.

Identified location within a physical or virtual address space.

Reserving space to store data or objects.

Amount of memory occupied or attributable to a program according to the chosen metric.

Memory consumption that remains held even though it is no longer useful, potentially degrading the system.

Returning a region that is no longer needed, either manually or automatically.

Integration of changes from several branches while preserving their historical relationship.

Situation in which Git cannot automatically integrate incompatible changes and requests resolution.

Sort algorithm that divides the data then merges sorted subsets, generally in O(n log n) time.

Intermediary service that receives, routes and redistributes messages between producers and consumers.

Mechanism for transmitting work or events between components through temporarily stored messages.

Function associated with an object, class or type.

Aggregated or point-in-time numerical measurement of a system's behaviour.

Architecture that splits a system into autonomous services communicating through interfaces, with increased operational cost.

Component inserted into a processing chain to apply a cross-cutting function to requests or responses.

Tracking point corresponding to an objective or set of work to be completed.

Reducing the size of distributed code by removing information not required for its operation.

Reusable set of behaviours added to a class or object, according to the language's mechanisms.

Collective programming practice in which several people contribute simultaneously to the same problem.

Program designed for mobile devices, with their interfaces and hardware constraints.

Approach that first builds the experience for small screens before enriching it for larger ones.

Test object that reproduces an interface while allowing verification of expected interactions.

Application deployed as a whole but divided into modules with explicit boundaries and dependencies.

Organization favouring autonomous and replaceable components through defined interfaces.

Organizational unit grouping code and possibly exposing an importable interface.

Operation that produces a remainder; rules regarding negative numbers differ between languages.

Continuous observation of the state and indicators of a service or application.

Application deployed or executed as a main unit, even if its code remains well modularized.

Repository grouping several projects or components within the same version history.

Identity verification combining several independent factors, such as possession and knowledge.

Use of multiple processes to carry out separate or parallel tasks.

Use of multiple threads of execution within a program.

Possibility of changing the state of an existing object.

Technique introducing small changes into the code to assess whether tests detect these alterations.

Mechanism that allows only one participant at a time to hold a mutual-exclusion lock.

Anti-pattern in which an initial query triggers an additional query per retrieved item.

Rule requiring that a column does not contain the SQL NULL value.

Context associating identifiers with elements to avoid or manage collisions.

Shared rule for forming consistent names, such as snake_case or camelCase.

Application built with APIs and conventions specific to a target system or platform.

Category of systems not primarily based on the classic relational model; it gathers varied models.

Compatibility determined mainly by identity or declared relations between types.

Constraint on quality or service conditions, such as performance, security or availability.

Marker for the absence of a value or reference, whose precise meaning depends on the language and schema.

Package manager and distribution ecosystem associated with JavaScript and Node.js.

Authorization delegation framework allowing an application to obtain limited access to protected resources.

Tool associating application objects with relational tables to facilitate certain persistence operations.

Software entity with an identity or value, possible state, and operations associated with it according to the model.

Building an object from other objects, favouring a "contains" relationship.

Approach that models the program through objects combining state and behaviour.

Ability to understand a system's internal state from its signals, notably logs, metrics and traces.

Pattern in which subscribers are notified when the state or events of a subject change.

State of a technology or feature that is no longer suitable, supported or maintained in a given context.

Software distributed under a license meeting the criteria of the Open Source Definition, beyond mere visibility of the code.

Specification that contractually describes HTTP APIs and enables documentation and tool generation.

Identity layer built on OAuth 2.0 to provide notably federated authentication.

Value or expression on which an operator acts.

Symbol or word that performs an operation on one or more values.

Conflict management that checks that no incompatible modification has occurred before validation.

Modification intended to improve a measurable property, such as speed or memory, without degrading essential constraints.

Transformation of special characters according to the destination context to prevent them from being interpreted as code.

Definition of several variants of an operation distinguished notably by their parameters according to the language.

Providing, in a subtype, a new implementation of an inherited method.

System that associates the responsibilities of possession and lifetime to values, notably in Rust.

HTTP method applying a partial modification to a resource according to the API's format and rules.

Language frequently used on the server side to produce dynamic applications and web pages.

HTTP method that submits data to be processed; its effect depends on the service and it is not intrinsically idempotent.

HTTP method requesting the creation or replacement of the targeted resource's state with the provided representation.

Web application leveraging adapted capabilities, such as installation or service worker, depending on the browser.

Set of modules or resources distributed or organized together; the meaning varies across ecosystems.

Tool that installs and resolves software or libraries distributed as packages.

Service hosting and distributing versions of published libraries and components.

Dividing a set of results into consumable portions fetched successively.

Practice in which two people work together on the same development, sharing analysis and review.

Effective execution of several computations at the same moment on distinct resources.

Name defined in a function's signature to receive data when it is called.

Type built from a template and one or more type parameters.

Fixing some arguments of a function in order to create a more specialized one.

Logical or physical division of data according to criteria that facilitate management or access.

Authentication credential that generally uses public-key cryptography and FIDO mechanisms.

One-way transformation with a salt and a suitable algorithm, such as Argon2id, to verify without storing the password in cleartext.

Value embedded in a URL path to identify a resource or part of a route.

Exploitation of uncontrolled paths to access files outside the authorized scope.

Verification of response times, throughput and resources under defined conditions.

Reserving or preemptively blocking resources to limit certain concurrent conflicts.

Component added to a host application to extend its behaviour via provided integration points.

Python tool that manages dependencies, environments and publishing from a project configuration.

Restoration of a database to a chosen point in time thanks to a backup and appropriate logs.

Value designating a memory address or accessible region, with rules specific to the language.

Possibility of using a common interface with different implementations or types.

Open-source relational DBMS offering notably transactions, advanced SQL, extensions and specialized types.

Function or expression that evaluates a condition and returns a logical result.

Anticipating the loading of data deemed likely to be used soon.

Performance refinement done before knowing the real needs or bottlenecks, at the risk of increasing complexity.

Tool that transforms source text before the main compilation steps.

Version identified as preceding a stable release, for example alpha, beta or release candidate.

Column or group of columns that uniquely identifies a row in a table.

Elementary type provided directly by a language or its environment, according to that language's own classification.

Granting only the permissions strictly necessary to an identity or component.

Collection whose removal favours elements based on a priority rather than just arrival order.

Organizing a program around procedures and sequences of statements.

Subroutine designed mainly to perform an action; the distinction with a function depends on the language.

Execution instance with its own address space and resources managed by the operating system.

Real environment in which a service or product is used by its end users.

Tool that analyzes processor, memory or other resource usage by calls and tasks.

Measuring a program's behaviour to identify the parts consuming time or resources.

Set of instructions intended to produce a behaviour when executed in a suitable environment.

Writing and organizing instructions that a machine can execute after interpretation or translation.

Notation system with rules that allow expressing computations and behaviours that can be executed.

Family of principles organizing how a program is described, such as the imperative or functional approach.

Tool that creates an initial structure of files and configuration from templates.

Object representing the future result of an asynchronous operation and its potential failure in some languages.

Limited experiment demonstrating the feasibility of an approach or technology.

Approach generating many inputs to check general invariants of a program.

Software distributed with limited rights by its owner; the source code may be inaccessible or subject to restrictions.

Exploratory implementation aimed at testing an idea, an interface or a feasibility, not necessarily intended for production.

Informal description of an algorithm that favours logic over the syntax of any concrete language.

Model in which producers publish events on channels to which consumers subscribe.

Proposal of changes submitted for discussion and verification before integration on a collaboration platform.

Function whose result depends only on its arguments and that produces no observable side effects.

Versatile dynamically typed language, used notably for scripting, automation, web and scientific computing.

Environment isolating notably a project's package installations from other Python environments.

Python package installation tool from indexes or other compatible sources.

Cross-platform framework for developing interfaces and applications, mainly used with C++ or Python.

Request sent to the data system to read or modify information.

Language designed to query or manipulate data, such as SQL; some also offer procedural features.

Improving data access strategy using filters, indexes and execution plans.

Data placed in the query portion of a URL, often used to filter or paginate.

Sort algorithm that partitions elements around a pivot, with performance sensitive to partitions.

Access control model founded on roles to which rights are associated.

Possibility for a remote actor to execute code on a system under unintended conditions.

Welcome document generally presenting a project's purpose, installation and first uses.

Interactive loop that reads an expression, evaluates it, prints the result and repeats.

Architectural style based on constraints such as identified resources, uniform interface and stateless server exchanges per request.

API designed to respect, more or less strictly, the principles of REST; simply using JSON and HTTP is not enough.

Statement that cancels the uncommitted changes of a transaction within the DBMS's limits.

Mechanism allowing a program to trigger an operation executed in another process or machine.

Defect or situation in which the result depends on an uncontrolled concurrent execution order.

Restriction of the number of operations allowed over a period or according to another quota rule.

JavaScript library for building user interfaces based on components and state.

Mobile application development framework using React and platform components.

Check designed to determine whether an instance is ready to serve requests.

Replaying a sequence of commits onto another base, which generally creates new commits.

Technique in which a function solves a problem by calling itself, directly or indirectly.

In-memory data system often used for caching, queues or fast structures, with various persistence options.

Operation that progressively aggregates the elements of a collection using an accumulator.

Modification of the internal structure of code aimed at preserving its observable behaviour.

Means of designating or accessing a value or object without necessarily copying its content.

Property that allows replacing an expression with its value without changing the program's behaviour.

Element used to request new access tokens according to the authorization server's rules.

Verification that a change has not reintroduced a previously fixed behaviour or degraded existing functionality.

Database that organizes data into relations, generally represented by tables and queried with SQL.

Organizing relations to reduce certain redundancies and modification anomalies.

Identified set of artefacts, notes and revisions made available for a given version.

Reference to a repository accessible elsewhere, frequently used to synchronize a team.

Maintaining copies of data across multiple instances for availability, reads or recovery.

Abstraction grouping access operations on persisted entities or aggregates.

Set of versioning data and files associated with a project.

Build aiming for identical artefacts from identified sources and inputs under controlled conditions.

Time elapsed between receiving a request and producing a response according to a defined scope.

Design that adapts presentation and interactions to device dimensions and capabilities.

Re-executing an operation after a presumed failure, to be designed with idempotence and duplicate risks in mind.

Statement that ends the call of a function and optionally transmits a result.

Result transmitted to the caller when a function terminates normally.

Service that receives client requests and forwards them to upstream application servers.

Evolving presentation of the priorities, objectives and steps envisaged for a product.

Search for the initial mechanisms that enabled an incident, beyond its immediate symptoms.

Set of values constituting an occurrence in a table or collection.

Dynamic object-oriented language, notably known for the Ruby on Rails framework.

Agent that executes the tasks of an automation pipeline.

Set of services and mechanisms required for a program to run, beyond its code alone.

Problem occurring during program execution, such as an invalid access.

Tool that allows installing and selecting multiple versions of a language or its environment.

Systems language featuring static ownership and borrowing control, aiming at memory safety without mandatory garbage collection.

Security-oriented static analysis of source code or its representations without running the application normally.

Structured inventory of software components present in a product to facilitate analysis and dependency tracking.

Examination of dependencies to identify their versions, licenses and known vulnerabilities.

Set of tools, libraries and documentation that allow developing for a platform or service.

SQL statement retrieving rows or computed results from the available data.

Contractual commitment defining service levels and possibly consequences in case of breach.

Measurement representing a dimension of the service, such as availability or successful latency.

Measurable target set on a reliability indicator over a given period.

Set of five object-oriented design principles aimed notably at managing responsibilities and dependencies.

Web application that updates much of its view without fully loading a new page at each navigation.

Declarative language for querying and managing relational databases, with dialects specific to systems.

Calculation summarizing several rows, for example using COUNT, SUM or AVG.

Description of the operations chosen by a DBMS to process a query, sometimes consultable with EXPLAIN.

Vulnerability in which untrusted data modifies the structure of an SQL query; bound parameters are a central protection.

Logical representation defined by a query and queryable like a table; any eventual materialization is separate.

Embedded relational DBMS that generally stores a database in a file and does not require a separate server.

Vulnerability allowing an attacker to drive a server to make requests to unintended destinations.

Sequence of local transactions coordinated with, often, compensating actions in case of failure.

Browser security rule restricting certain accesses between documents or scripts of different origins.

Component that decides which tasks or execution units progress at what moment.

Region of the program in which a name can be resolved and used.

Program often used to automate a task or orchestrate tools; its size and execution mode vary.

Agile framework based on roles, events and artefacts to manage a complex product.

Service that centralizes the storage and controlled access to credentials and other application secrets.

Renewing a secret and updating its consumers to reduce the risks linked to its lifetime.

Set of practices for creating, storing, distributing, rotating and revoking sensitive credentials.

Assessment aimed at identifying defects of confidentiality, integrity, access or other security properties.

MAJOR.MINOR.PATCH convention: API-breaking change, compatible addition then compatible fix, once the API is defined.

Meaning or behaviour associated with the constructs of a language, beyond their syntactic form.

Synchronization counter limiting the number of accesses or signalling available resources.

Dividing the system into parts whose functions are distinct and understandable.

Transformation of a structure into a transmittable or storable representation.

HTTP mechanism sending a stream of events from the server to the browser, mainly in one direction.

Limiting the number of items returned per request to avoid an excessive response.

Generation of the initial HTML by a server before sending it to the browser.

Script that runs separately from the page, capable notably of intercepting certain requests and managing off-page tasks.

Collection of unique elements, usually without a conceptual order guarantee.

Encapsulated DOM tree that partly isolates the structure and styles of a component.

Copy of a structure that retains references to some internal elements.

Horizontal distribution of a dataset across multiple distinct partitions or servers.

Command interpreter used to launch programs and automate their chaining.

Evaluation that skips the second operand when the first is enough to determine the result.

Observable modification other than producing the return value, such as a write or a network request.

Principle that invites concentrating a module on a coherent responsibility, interpreted according to context.

Pattern aimed at a shared, controlled instance; it can introduce hard-to-test global state.

Quick set of checks ensuring that the main functions are usable after a change or delivery.

Package format and application distribution infrastructure with confinement according to configuration.

Software communication endpoint used to exchange data locally or over a network.

Set of programs, resources and data constituting a computer product or service.

Organization of components, their responsibilities and their interactions, along with the system's structural decisions.

Isolated execution environment at the operating system level, generally sharing its kernel.

Activity consisting of designing, programming, testing, delivering and evolving a software product that meets identified needs.

Set of steps leading from expressing a need through designing, building, operating and retiring a software.

Set of reusable functions, types or resources that a program calls upon to accomplish certain tasks.

Text defining the rights and obligations linked to the use, modification and redistribution of software.

Set of providers, dependencies, tools and steps contributing to the production and distribution of software.

Activity that aims to verify behaviours and reveal defects through defined checks.

Arranging elements according to a defined order relation.

Text written in a programming language, before or independently of its transformation into an executable program.

Estimate of the growth of memory resources according to problem size.

Unit of a trace describing an operation, its duration and its relations with other operations.

Document or set of rules detailing the expected behaviours and constraints of a system.

Fixed-duration work period used notably in Scrum to reach a defined goal.

Substitute or instrument that records the calls made to enable their verification.

Sort that preserves the relative order of elements compared as equal.

Memory region or mechanism notably handling call contexts; its organization varies across runtimes.

List of the calls that led to a failure point, useful for locating its origin.

Validation environment that aims to reproduce characteristics relevant to production.

Situation in which a task is durably deprived of the resources needed to progress.

Construct that requests an action, such as an assignment or a return.

Examination of code without normally running the program to detect problems or properties.

Pre-production of pages ready to be served without systematic dynamic rendering for each request.

Language in which many type checks happen before execution; dynamic behaviour may still be possible.

Driven execution mode that advances one statement or call at a time.

Pattern that makes several algorithms interchangeable behind a common interface.

Trial pushing the system beyond its normal operation to observe its limits and recovery.

Sequence of characters or text units used to represent textual content.

Guarantee giving certain reads a recent and coordinated view of writes according to a defined model.

Type compatibility determined by shape and members rather than by a common declaration.

Recording of traces as exploitable fields, often serialized in JSON.

Minimal replacement providing predetermined results to isolate a tested component.

Query embedded in another query to provide a value, list or relation.

Interface tool that transforms components at compile time, with an adapted runtime.

Language developed for Apple platforms and other environments, with modern type and memory management.

Construct that selects one case among several; match can also analyze the structure of a value.

Rules that determine how to assemble the valid symbols and constructs of a language.

Code that does not respect the language's grammar and is often rejected before execution.

Design practice alternating a failing test, minimal implementation and refactoring.

Protocol that protects network communications through encryption, integrity and authentication depending on its use.

Defined validity period for a piece of data or a token before expiry; its meaning depends on the system.

Interactive interface using a grid of characters in a terminal.

Relational structure representing rows under a defined set of columns.

Unit of work scheduled by an asynchronous environment that can generally be awaited or cancelled.

Desktop framework pairing a native core, generally Rust, with an interface rendered by the system's WebView.

Optimizations that facilitate crawling, indexing and interpretation of a site by search engines.

Future cost of design or maintenance trade-offs; not all debt is necessarily accidental.

Set of information needed to understand, install, operate or modify a system.

Application that displays a textual interface and generally forwards input to a shell or program.

Three-operand construct, frequently used to select a value based on a condition.

Declarative infrastructure management tool that describes and applies a desired state via providers.

Explicit check of an expected property or result; its failure makes the test fail.

Description of the preconditions, actions and expected results of a verification.

Generic term for a component substitute used in a test.

Model suggesting a distribution between fast targeted checks and more integrated scenarios.

Sequence of instructions executed within a process, generally sharing its memory with other threads of the same process.

Analysis of assets, actors, scenarios and protective measures from the design of a system.

Technique that caps the number of executions of a process over a period.

Quantity of operations or data processed per unit of time.

Tracking unit documenting a task, defect or request along with its state and context.

Estimate of the growth of computation time as a function of input size.

Maximum time allowed for an operation before waiting is stopped or it is reported as expired.

Coordinated set of compiler, linker, build tools and other utilities.

Unit of reusable behaviours or contracts; its rules differ between Rust, PHP and other languages.

Group of operations treated as a unit of consistency, committed or rolled back according to the system's guarantees.

Pattern storing in the same transaction the business change and an event to be published later.

Package required by another dependency of the project rather than declared directly by it.

Translation from one high-level language to another of comparable level, for example TypeScript to JavaScript.

Hierarchical structure of linked nodes without a cycle in its classical form.

Eliminating exported but unused code during a build, when analysis permits it.

Generally fixed-size collection of positions, often used to group several values.

Tool that analyzes type compatibility and the consistency of annotations according to its supported rules.

Moving a value or reference to another type, either explicitly or implicitly.

Automatic determination of types by the compiler or a tool from context.

Set of guarantees limiting certain operations that are incompatible with the types, under varying definitions.

Language that notably adds a static type system to JavaScript and is generally transpiled to JavaScript for execution.

Reusable interface unit combining rendering, properties and optionally behaviour.

SQL statement that modifies existing rows selected by the indicated conditions.

Standardized identifier for a resource; a URL is a form of URI that gives access indications.

Address identifying the location of a resource and the means to access it.

Variable-length Unicode encoding compatible with ASCII for basic characters.

State distinct from null in some languages, notably JavaScript, signalling a value that has not been provided.

Standard that identifies characters and defines their processing independently of any particular encoding.

Rule prohibiting certain duplicated values in a column or set of columns.

Test targeting a small unit of behaviour and generally controlling its dependencies.

Portion of a program that cannot be reached under the execution conditions considered.

Reconstruction of objects from untrusted data that can trigger code execution or other dangerous effects.

Description of the interactions between an actor and a system to achieve a goal.

Concise formulation of a user need that serves as a support for discussion and validation.

Data represented, transmitted or stored by an expression, variable or structure.

Domain element defined by its properties rather than by an identity of its own, often immutable.

Name bound to a value or to a location whose contents may change depending on the language.

Declaration of a name that hides a same-named declaration from an enclosing scope.

System that maintains the history of file changes and facilitates comparison, rollback and collaboration.

Increasing capacity by strengthening the resources of a single instance.

Abstract representation of the interface used by some frameworks to compute updates.

JavaScript interface framework using components, reactivity and declarative templates.

International recommendations providing conformance criteria for web content accessibility.

Debugger feature displaying the evolution of a selected variable or expression.

Design that allows as many people as possible to use a service, notably with assistive technologies or without a mouse.

Web component based on standards such as custom elements and optionally Shadow DOM.

Logical state linking several requests from a user, usually via an identifier or token.

Transformation of web source code to a syntax or target compatible with the intended environments.

Portable binary instruction format designed for isolated execution and efficient performance across various hosts.

Protocol enabling persistent bidirectional communication over a connection established from an HTTP negotiation.

Component that integrates the rendering of web content within a native application.

Notification sent by a service to a configured URL when an event occurs; authenticity and retries must be handled.

Repetition that tests a condition before each iteration.

State of files checked out from the repository, including their local modifications.

Input or situation producing the maximum considered cost for a given size.

Extensible markup language representing structured data in a textual document.

Injection of executable content into a web context consulted by other users, depending on vectors and protections.

Principle advising against implementing today features that are only hypothetical.

Human-readable data serialization language, used notably for configuration.

Mechanism by which a generator produces a value while temporarily suspending its execution.