Software Development Glossary

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Logical type representing two values, generally true and false.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Identified location within a physical or virtual address space.

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

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

Reserving space to store data or objects.

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

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

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

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

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

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

Possibility of changing the state of an existing object.

Transformation of a structure into a transmittable or storable representation.

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

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

Value or expression on which an operator acts.

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

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

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

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

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

Increasing a value, usually by one unit.

Decreasing a value, usually by one unit.

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

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

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

Expression whose result drives an execution choice.

Change in execution path based on a condition or destination.

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

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

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

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

Repetition that tests a condition before each iteration.

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

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

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

Object that holds traversal state and yields successive elements.

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

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

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

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

Situation that stops recursive calls and prevents infinite recursion.

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

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

Mechanism that allows catching, processing or propagating an exception.

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

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

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

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

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

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

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

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

Result transmitted to the caller when a function terminates normally.

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

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

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

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

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

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

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

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

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

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

Organizational unit grouping code and possibly exposing an importable interface.

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

Making available elements defined in another module or namespace.

Context associating identifiers with elements to avoid or manage collisions.

Element explicitly exposed by a module to its consumers.

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

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

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

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

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

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

Building a function by chaining the results of several functions.

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

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

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

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

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

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

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

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

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

Organizing a program around procedures and sequences of statements.

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

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

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

Object created from a particular class or model.

Data or property attached to an object or class.

Function associated with an object, class or type.

Mechanism involved in the creation or initialization of an object.

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

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

Representation that exposes the necessary aspects while hiding implementation details.

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

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

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

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.

Contract describing accessible operations without necessarily imposing their implementation.

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

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

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

Definition of structures or functions parameterized by types.

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

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

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

Compatibility determined mainly by identity or declared relations between types.

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

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

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

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

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

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

Graphical representation of processes and decisions through connected shapes.

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

Estimate of the growth of memory resources according to problem 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.

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

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

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

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

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

Arranging elements according to a defined order relation.

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

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

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

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

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

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

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

Structure where the last element added is the first removed.

Structure where the first element added is the first removed.

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

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

Tree in which each node has at most two children.

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

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

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

Exploring a graph level by level using a queue.

Exploration following a branch as far as possible before backtracking.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Tool that transforms source text before the main compilation steps.

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

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

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

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

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

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

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

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

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.

Model in which the programmer explicitly controls allocations and releases.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Degree of closeness of the responsibilities gathered within a module.

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

Organization favouring autonomous and replaceable components through defined interfaces.

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

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

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

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

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

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

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

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

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

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

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

Construction that centralizes or abstracts the creation of objects.

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

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

Pattern that makes several algorithms interchangeable behind a common interface.

Abstraction grouping access operations on persisted entities or aggregates.

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

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

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

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

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

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

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

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

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

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

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

Principle of avoiding unnecessary complexity for the actual need.

Principle advising against implementing today features that are only hypothetical.

Approach that provides consistent default behaviours to reduce explicit configuration.

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

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

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

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

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

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

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

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

Expression identifying the elements to which a style rule applies.

Priority rule used to break ties between competing CSS declarations.

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

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

CSS layout model based on coordinated rows and columns.

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

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

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

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

International recommendations providing conformance criteria for web content accessibility.

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

Reusable interface unit combining rendering, properties and optionally behaviour.

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

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

Significant generation of the interface in the browser using JavaScript.

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

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

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

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

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

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

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

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

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

JavaScript interface framework using components, reactivity and declarative templates.

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

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

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

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

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

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

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

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

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

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

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

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.

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

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.

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

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

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

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.

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

Extensible markup language representing structured data in a textual document.

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

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

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

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

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

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

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

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

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

Dividing a set of results into consumable portions fetched successively.

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

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

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

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

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

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

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

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

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

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

Relational structure representing rows under a defined set of columns.

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

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

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

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

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

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

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

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

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

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

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

SQL statement that adds new rows to a table.

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

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

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

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

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

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

SQL clause grouping rows to compute aggregates per group.

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

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

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

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

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

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

Statement that validates the changes of a transaction.

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

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

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

Reserving or preemptively blocking resources to limit certain concurrent conflicts.

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

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

Organizing relations to reduce certain redundancies and modification anomalies.

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

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

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

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

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

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

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

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

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

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

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

Use of multiple threads of execution within a program.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Program intended primarily for personal computers and their operating systems.

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

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

Interface driven by entering textual commands and arguments.

Interactive interface using a grid of characters in a terminal.

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

Command interpreter used to launch programs and automate their chaining.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Framework for building interfaces compiled for multiple platforms using Dart.

Mobile application development framework using React and platform components.

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

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

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

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

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

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

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

Set of versioning data and files associated with a project.

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

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

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.

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

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

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

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

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

Command placing selected file versions or changes into the index.

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

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

Command displaying the history of commits and associated information.

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

Test verifying the real interaction of several components or systems.

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

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

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

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

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

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

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

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

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

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

Minimal replacement providing predetermined results to isolate a tested component.

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

Generic term for a component substitute used in a test.

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

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

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

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

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

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

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

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

Approach that describes and verifies observable behaviour from shared examples.

Scenario structure expressing context, action and expected outcome.

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

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

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

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

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

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

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

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

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

Tool that automatically applies a standardized presentation to source code.

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

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

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

Process of identifying, explaining and fixing a program defect.

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

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

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

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

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

Location or condition that suspends the program in a debugger.

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

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

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

Structured or textual production of event traces during execution.

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

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

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

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

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

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

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

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

Triggering a notification when an important operational condition is detected.

Unexpected stop of a program, process or component.

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

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

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

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

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

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

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.

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.

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

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

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

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

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

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

Service hosting and distributing versions of published libraries and components.

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

Python package installation tool from indexes or other compatible sources.

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

Official package manager and build tool of the Rust ecosystem.

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

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

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

File recording the resolved versions to facilitate installation reproducibility.

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

Agent that executes the tasks of an automation pipeline.

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

Validation environment that aims to reproduce characteristics relevant to production.

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

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.

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

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

Versioned description of infrastructure resources using files and automation tools.

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

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

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

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

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

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

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

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

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

Platform that orchestrates containerized workloads using declarative resources and controllers.

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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.

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

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

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

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

Comparative performance measurement under reproducible and documented conditions.

Duration between a request and the observed response or effect.

Quantity of operations or data processed per unit of time.

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

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

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

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

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

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

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

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

Grouping several operations to reduce fixed processing or communication costs.

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

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

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

Set of reusable connections that avoid repeating costly creations.

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

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

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

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

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

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

Increasing capacity by adding instances or machines.

Increasing capacity by strengthening the resources of a single instance.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Version limited enough to test essential hypotheses with real users.

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

Limited experiment demonstrating the feasibility of an approach or technology.

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

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

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

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

Uncertain evaluation of effort, duration or complexity before realization.

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

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

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

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

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

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

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

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

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

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

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

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

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