Glossaire du développement

Activité consistant à concevoir, programmer, tester, livrer et faire évoluer un logiciel répondant à des besoins identifiés.

Écriture et organisation d'instructions qu'une machine pourra exécuter après interprétation ou traduction.

Texte écrit dans un langage de programmation, avant ou indépendamment de sa transformation en programme exécutable.

Ensemble d'instructions destiné à produire un comportement lorsqu'il est exécuté dans un environnement adapté.

Ensemble de programmes, ressources et données constituant un produit ou un service informatique.

Logiciel conçu pour rendre un service à un utilisateur ou à un autre système.

Programme souvent employé pour automatiser une tâche ou orchestrer des outils ; sa taille et son mode d'exécution varient.

Système de notation doté de règles permettant d'exprimer des calculs et comportements exécutables.

Langage structurant des contenus au moyen de marqueurs ; HTML décrit des documents et n'est pas, à lui seul, un langage de programmation généraliste.

Langage conçu pour interroger ou manipuler des données, comme SQL ; certains offrent aussi des fonctions procédurales.

Règles qui déterminent comment assembler les symboles et constructions valides d'un langage.

Sens ou comportement associé aux constructions d'un langage, au-delà de leur forme syntaxique.

Construction qui demande d'effectuer une action, telle qu'une affectation ou un retour.

Construction évaluée pour produire une valeur, éventuellement accompagnée d'effets de bord.

Instruction réunissant plusieurs instructions sous une structure commune, comme un bloc conditionnel.

Nom utilisé pour désigner une variable, une fonction, une classe ou un autre élément de programme.

Mot réservé ou doté d'un rôle spécial dans la grammaire d'un langage.

Écriture directe d'une valeur dans le code, par exemple 42, true ou "bonjour".

Texte du code destiné aux lecteurs ou aux outils, généralement ignoré lors de l'exécution.

Règle collective pour former des noms cohérents, comme snake_case ou camelCase.

Espacement initial des lignes facilitant la lecture et participant parfois à la syntaxe, notamment en Python.

Groupe d'instructions délimité par la syntaxe du langage ou par son indentation.

Emplacement à partir duquel démarre l'exécution d'un programme ou d'un composant.

Mise en œuvre des instructions d'un programme par un environnement matériel ou logiciel.

Ensemble de services et mécanismes nécessaires à l'exécution d'un programme, au-delà de son seul code.

Fichier contenant du code et des informations permettant son chargement et son lancement par un système compatible.

Composant extérieur dont le fonctionnement d'un projet nécessite l'utilisation.

Capacité d'une nouvelle version à accepter les usages ou données d'une version antérieure ; les garanties exactes dépendent du contrat.

Signal qu'une fonctionnalité reste disponible pour l'instant mais n'est plus recommandée et pourrait être retirée.

État d'une technologie ou d'une fonctionnalité qui n'est plus adaptée, prise en charge ou maintenue selon un contexte donné.

Nom associé à une valeur ou à un emplacement dont le contenu peut éventuellement changer selon le langage.

Valeur ou liaison présentée comme non réassignable ; cela n'implique pas toujours l'immuabilité des objets référencés.

Opération qui attribue une valeur à une variable, un champ ou un emplacement.

Introduction d'un nom et parfois de son type, de sa portée ou de ses propriétés.

Attribution de l'état ou de la première valeur utilisable d'une variable ou d'un objet.

Ensemble de valeurs possibles accompagné des opérations et contraintes qui leur sont associées.

Type élémentaire proposé directement par un langage ou son environnement, selon une classification propre à celui-ci.

Type logique représentant deux valeurs, généralement vrai et faux.

Nombre sans partie fractionnaire, avec une taille et des limites qui dépendent de sa représentation.

Représentation numérique approximative d'une plage de valeurs réelles ; elle peut introduire des erreurs d'arrondi.

Représentation adaptée à certains calculs décimaux, notamment financiers, sous réserve de précision et de règles définies.

Suite de caractères ou d'unités de texte utilisée pour représenter du contenu textuel.

Unité textuelle ; point de code Unicode, unité de code et caractère perçu ne coïncident pas toujours.

Standard identifiant des caractères et définissant leur traitement indépendamment d'un encodage particulier.

Encodage Unicode à longueur variable compatible avec ASCII pour les caractères de base.

Marqueur d'absence de valeur ou de référence, dont la signification précise dépend du langage et du schéma.

État distinct de null dans certains langages, notamment JavaScript, signalant une valeur non fournie.

Structure permettant d'accéder à plusieurs éléments, souvent par index ; sa taille et son homogénéité varient.

Collection ordonnée d'éléments dont les propriétés et performances dépendent de l'implémentation.

Collection de positions généralement fixe en nombre, souvent utilisée pour regrouper plusieurs valeurs.

Collection d'éléments uniques, généralement sans garantie d'ordre conceptuel.

Structure associant des clés à des valeurs pour effectuer des recherches par clé.

Identifiant utilisé pour retrouver une valeur dans une table associative ou une structure de données.

Donnée représentée, transmise ou stockée par une expression, une variable ou une structure.

Position ou clé d'accès ; dans les séquences, la numérotation commence souvent à zéro, mais pas toujours.

Moyen de désigner ou d'accéder à une valeur ou à un objet sans nécessairement en copier le contenu.

Valeur désignant une adresse mémoire ou une zone accessible, avec des règles propres au langage.

Emplacement identifié dans un espace d'adressage physique ou virtuel.

Zone ou mécanisme gérant notamment les contextes d'appels ; son organisation varie selon le runtime.

Région de mémoire utilisée notamment pour des allocations dont la durée de vie ne suit pas simplement les appels.

Réservation d'espace pour stocker des données ou des objets.

Restitution d'une zone qui n'est plus nécessaire, manuelle ou automatisée.

Mécanisme automatisant la récupération de mémoire devenue inaccessible selon ses règles de suivi.

Consommation de mémoire qui reste retenue alors qu'elle n'est plus utile, pouvant dégrader le système.

Copie d'une structure qui conserve les références vers certains éléments internes.

Copie récursive de sous-objets selon des règles définies, visant à limiter le partage involontaire.

Propriété empêchant la modification d'une valeur ou d'un objet après sa création.

Possibilité de changer l'état d'un objet existant.

Transformation d'une structure en représentation transmissible ou stockable.

Reconstruction d'une structure à partir d'une représentation sérialisée, opération à sécuriser pour les formats dangereux.

Symbole ou mot réalisant une opération sur une ou plusieurs valeurs.

Valeur ou expression sur laquelle agit un opérateur.

Opérateur réalisant un calcul numérique, par exemple une addition ou une division.

Opérateur évaluant une relation, comme égalité, ordre ou identité selon le langage.

Opérateur combinant ou inversant des conditions, tel que ET, OU ou NON.

Évaluation qui omet le second opérande lorsque le premier suffit à déterminer le résultat.

Construction à trois opérandes, fréquemment utilisée pour sélectionner une valeur selon une condition.

Augmentation d'une valeur, souvent de une unité.

Diminution d'une valeur, souvent de une unité.

Opération produisant un reste ; les règles relatives aux nombres négatifs diffèrent selon les langages.

Passage d'une valeur ou d'une référence vers un autre type, explicitement ou implicitement.

Conversion implicite imposée par les règles d'un langage lors d'une opération.

Expression dont le résultat pilote un choix d'exécution.

Modification du parcours d'exécution selon une condition ou une destination.

Construction qui exécute un bloc si une condition est satisfaite et éventuellement un autre sinon.

Construction choisissant un cas parmi plusieurs ; match peut également analyser la structure d'une valeur.

Construction répétant des instructions tant qu'une condition ou une séquence le prévoit.

Forme de répétition généralement fondée sur un compteur ou sur le parcours d'une collection.

Répétition qui teste une condition avant chaque itération.

Répétition qui exécute son corps avant le contrôle de poursuite, lorsqu'elle est proposée par le langage.

Passage individuel d'une boucle ou opération successive de parcours d'une collection.

Objet pouvant fournir une séquence d'éléments à parcourir selon un protocole donné.

Objet conservant un état de parcours et fournissant les éléments successifs.

Instruction quittant une boucle ou une construction sélectionnable selon les règles du langage.

Instruction passant à l'itération suivante d'une boucle sans exécuter le reste de l'itération courante.

Instruction mettant fin à l'appel d'une fonction et transmettant éventuellement un résultat.

Technique où une fonction résout un problème en s'appelant elle-même, directement ou indirectement.

Situation arrêtant les appels récursifs et empêchant une récursion sans fin.

Modification observable autre que la production de la valeur de retour, telle qu'une écriture ou une requête réseau.

Signalement d'une situation inhabituelle interrompant le flux normal jusqu'à son traitement éventuel.

Mécanisme permettant de capturer, traiter ou propager une exception.

Bloc exécuté à la sortie d'une structure de gestion d'exception selon les règles du langage, souvent pour nettoyer des ressources.

Vérification d'une hypothèse de programmation pouvant provoquer un signal d'échec ; elle ne remplace pas une validation de données non fiables.

Portion de programme qui ne peut pas être atteinte dans les conditions d'exécution considérées.

Unité de code réutilisable qui reçoit éventuellement des arguments et produit un résultat ou des effets.

Sous-programme conçu principalement pour réaliser une action ; la distinction avec fonction dépend du langage.

Nom défini dans la signature d'une fonction pour recevoir une donnée lors de l'appel.

Valeur ou expression effectivement fournie à une fonction lors de son appel.

Description de l'interface d'appel, comprenant selon le langage nom, paramètres, types et résultat.

Résultat transmis à l'appelant lorsqu'une fonction se termine normalement.

Instruction ou expression qui déclenche l'exécution d'une fonction avec des arguments donnés.

Fonction définie sans nom déclaré, souvent utilisée localement ou transmise comme valeur.

Fonction remise à un composant qui l'appellera lors d'un événement ou d'une opération.

Fonction prenant une fonction comme argument ou renvoyant une fonction.

Fonction conservant l'accès à certaines liaisons de son contexte lexical après la sortie de celui-ci.

Zone du programme où un nom peut être résolu et utilisé.

Résolution des noms selon la structure du code source plutôt que la chaîne dynamique des appels.

Variable accessible dans une portée limitée, typiquement une fonction ou un bloc.

Variable définie dans une portée générale ; son usage peut augmenter le couplage.

Déclaration d'un nom qui cache une déclaration homonyme d'une portée englobante.

Unité d'organisation regroupant du code et exposant éventuellement une interface importable.

Ensemble de modules ou ressources diffusés ou organisés ensemble ; le sens varie selon l'écosystème.

Mise à disposition d'éléments définis dans un autre module ou espace de noms.

Contexte associant des identifiants à des éléments pour éviter ou gérer les collisions.

Élément explicitement exposé par un module à ses consommateurs.

Fonction dont le résultat dépend uniquement de ses arguments et qui ne produit pas d'effets de bord observables.

Propriété permettant de remplacer une expression par sa valeur sans changer le comportement du programme.

Opération qui applique une transformation à chaque élément d'une collection.

Opération qui conserve les éléments d'une collection satisfaisant un prédicat.

Opération qui agrège progressivement les éléments d'une collection à l'aide d'un accumulateur.

Fonction ou expression évaluant une condition et renvoyant un résultat logique.

Construction d'une fonction en enchaînant les résultats de plusieurs fonctions.

Transformation conceptuelle d'une fonction à plusieurs arguments en succession de fonctions à un argument.

Fixation de certains arguments d'une fonction afin d'en créer une autre plus spécialisée.

Mise en cache des résultats d'appels pour éviter des recalculs avec les mêmes entrées.

Construction qui produit des valeurs au fil du parcours plutôt que de créer obligatoirement toute la séquence.

Mécanisme par lequel un générateur produit une valeur tout en suspendant temporairement son exécution.

Objet ou construction qui encadre acquisition et libération de ressources, comme un fichier ouvert.

Famille de principes organisant la manière de décrire un programme, telle que l'approche impérative ou fonctionnelle.

Approche qui décrit les opérations et changements d'état à effectuer.

Approche qui exprime le résultat ou les contraintes recherchées plutôt qu'une suite explicite d'opérations.

Organisation d'un programme autour de procédures et de séquences d'instructions.

Approche modélisant le programme par des objets associant état et comportement.

Définition servant à construire des objets et à décrire leurs attributs, méthodes ou contrats.

Entité logicielle possédant une identité ou une valeur, un état éventuel et des opérations associées selon le modèle.

Objet créé à partir d'une classe ou d'un modèle particulier.

Donnée ou propriété rattachée à un objet ou à une classe.

Fonction associée à un objet, une classe ou un type.

Mécanisme intervenant lors de la création ou de l'initialisation d'un objet.

Mécanisme de finalisation prévu par certains langages ; son moment d'exécution peut être incertain.

Regroupement de données et d'opérations derrière une interface contrôlant leur accès.

Représentation qui expose les aspects nécessaires et masque des détails d'implémentation.

Mécanisme permettant de dériver une classe ou un type d'un autre afin de réutiliser ou spécialiser son comportement.

Construction d'un objet à partir d'autres objets, privilégiant une relation « contient ».

Possibilité d'utiliser une interface commune avec des implémentations ou des types différents.

Définition de plusieurs variantes d'une opération distinguées notamment par leurs paramètres selon le langage.

Fourniture, dans un sous-type, d'une nouvelle implémentation d'une méthode héritée.

Contrat décrivant les opérations accessibles sans imposer nécessairement leur implémentation.

Classe conçue pour servir de base et pouvant comporter des opérations sans implémentation complète.

Ensemble réutilisable de comportements ajouté à une classe ou un objet, selon les mécanismes du langage.

Unité de comportements ou de contrats réutilisables ; ses règles diffèrent entre Rust, PHP et d'autres langages.

Définition de structures ou fonctions paramétrées par des types.

Type construit à partir d'un modèle et d'un ou plusieurs paramètres de type.

Pratique consistant à exploiter un objet selon les opérations qu'il fournit plutôt que sa classe déclarée.

Compatibilité de types déterminée par leur forme et leurs membres plutôt que par une déclaration commune.

Compatibilité déterminée principalement par l'identité ou les relations déclarées entre types.

Ensemble de cinq principes de conception orientée objet visant notamment à maîtriser les responsabilités et dépendances.

Principe invitant à concentrer un module sur une responsabilité cohérente, interprétée selon le contexte.

Principe selon lequel les modules de haut niveau et de bas niveau dépendent d'abstractions adaptées.

Fourniture de composants nécessaires depuis l'extérieur plutôt que leur création directe au cœur du consommateur.

Suite finie et précise d'étapes destinée à résoudre un problème ou à effectuer un calcul.

Description informelle d'un algorithme qui privilégie la logique plutôt que la syntaxe d'un langage concret.

Représentation graphique de processus et de décisions par des formes reliées.

Estimation de la croissance du temps de calcul en fonction de la taille de l'entrée.

Estimation de la croissance des ressources mémoire nécessaires selon la taille du problème.

Borne asymptotique supérieure de croissance, souvent utilisée pour exprimer un coût algorithmique.

Borne asymptotique inférieure d'une fonction de coût ou de croissance.

Encadrement asymptotique à la fois supérieur et inférieur d'une fonction.

Entrée ou situation conduisant au coût le plus favorable pour une taille donnée.

Entrée ou situation produisant le coût maximal considéré pour une taille donnée.

Coût moyen par opération sur une séquence d'opérations, sans nécessairement supposer une distribution aléatoire.

Recherche parcourant successivement les éléments jusqu'à trouver la cible ou épuiser la collection.

Recherche divisant à répétition un domaine ordonné en deux pour réduire les possibilités.

Organisation d'éléments selon une relation d'ordre définie.

Algorithme de tri partitionnant les éléments autour d'un pivot, avec des performances sensibles aux partitions.

Algorithme divisant les données puis fusionnant des sous-ensembles triés, généralement en temps O(n log n).

Tri construisant progressivement une partie ordonnée, efficace notamment sur de petites données presque triées.

Tri qui préserve l'ordre relatif des éléments comparés comme égaux.

Structure qui transforme les clés en emplacements pour accélérer en moyenne leur recherche.

Situation où différentes clés aboutissent au même emplacement ou à la même empreinte.

Structure d'éléments reliés par références, facilitant certaines insertions au prix d'accès séquentiels.

Structure où le dernier élément ajouté est le premier retiré.

Structure où le premier élément ajouté est le premier retiré.

Collection dont le retrait favorise les éléments selon une priorité plutôt que leur seul ordre d'arrivée.

Structure hiérarchique de nœuds liés sans cycle dans sa forme classique.

Arbre dans lequel chaque nœud possède au plus deux enfants.

Arbre dont les nœuds respectent une relation d'ordre facilitant recherches et mises à jour.

Arbre presque complet généralement stocké en tableau et ordonné localement par priorité.

Ensemble de sommets et de liens modélisant des relations, orientées ou non.

Exploration d'un graphe par niveaux à l'aide d'une file.

Exploration suivant une branche aussi loin que possible avant retour en arrière.

Méthode réutilisant des résultats de sous-problèmes recouvrants afin d'éviter leur recalcul.

Méthode réalisant des choix locaux successifs, dont l'optimalité globale doit être justifiée selon le problème.

Résolution décomposant un problème en sous-problèmes puis combinant leurs résultats.

Exploration de solutions candidates avec abandon d'une branche lorsqu'elle ne convient plus.

Règle pratique cherchant une solution acceptable sans garantir toujours l'optimum.

Propriété qui demeure vraie avant et après chaque itération et aide à démontrer la correction.

Outil traduisant un langage source vers une autre représentation, souvent du code machine ou un langage intermédiaire.

Programme évaluant ou exécutant des instructions via un environnement d'interprétation ; certaines implémentations combinent compilation et interprétation.

Instructions binaires propres à une architecture de processeur et exécutables par elle.

Langage de bas niveau représentant des instructions machine par des mnémoniques et symboles.

Représentation intermédiaire d'instructions destinée à une machine virtuelle ou à un moteur d'exécution.

Environnement logiciel exécutant du bytecode ou du code intermédiaire, comme la JVM.

Compilation durant l'exécution, souvent pour optimiser les portions de code les plus utilisées.

Traduction du code avant son exécution, par opposition à la compilation à la volée.

Traduction d'un langage de haut niveau vers un autre niveau comparable, par exemple TypeScript vers JavaScript.

Outil transformant le texte source avant les étapes principales de compilation.

Outil réunissant des objets compilés et résolvant leurs symboles pour produire un artefact lié.

Composant chargeant un exécutable et ses dépendances en mémoire avant son démarrage.

Ensemble coordonné de compilateur, éditeur de liens, outils de compilation et autres utilitaires.

Ensemble d'outils, bibliothèques et documentation permettant de développer pour une plateforme ou un service.

Contrat exposant des fonctions, opérations ou données utilisables par d'autres logiciels ; une API n'est pas nécessairement accessible par réseau.

Convention définissant comment du code compilé interagit au niveau binaire : appels, données, symboles et autres règles.

Langage dont de nombreuses vérifications de types se font avant l'exécution ; des comportements dynamiques restent possibles.

Langage où l'appartenance des valeurs à des types est principalement déterminée et vérifiée à l'exécution.

Détermination automatique de types par le compilateur ou un outil à partir du contexte.

Ensemble de garanties limitant certaines opérations incompatibles avec les types, selon des définitions variables.

Modèle dans lequel le programmeur contrôle explicitement des allocations et libérations.

Système associant les responsabilités de possession et de durée de vie à des valeurs, notamment en Rust.

Accès temporaire à une valeur sans transfert de propriété, encadré par les règles du langage.

Période pendant laquelle une référence ou ressource reste valide au regard des garanties du programme.

Production d'un programme pour une plateforme différente de celle qui réalise la compilation.

Système, architecture et environnement pour lesquels un artefact est construit.

Boucle interactive qui lit une expression, l'évalue, affiche le résultat et recommence.

Langage polyvalent à typage dynamique, employé notamment pour scripts, automatisation, web et calcul scientifique.

Langage de programmation standardisé par ECMAScript, utilisé dans les navigateurs et de nombreux environnements serveur.

Langage ajoutant notamment un système de types statiques à JavaScript et généralement converti en JavaScript pour l'exécution.

Langage orienté objet et multiparadigme généralement compilé en bytecode exécuté notamment sur la JVM.

Langage généraliste proche des représentations machine, utilisé entre autres pour systèmes et bibliothèques.

Langage généraliste dérivé du C, associant programmation bas niveau, objets, génériques et abstractions.

Langage multiparadigme de l'écosystème .NET utilisé notamment pour applications, services et jeux.

Langage système doté d'un contrôle statique de la propriété et des emprunts visant une sécurité mémoire sans ramasse-miettes obligatoire.

Langage compilé conçu autour de la simplicité des outils, de la concurrence et des services réseau.

Langage fréquemment utilisé côté serveur pour produire des applications et pages web dynamiques.

Langage dynamique orienté objet, notamment connu pour le framework Ruby on Rails.

Langage à typage statique interopérable notamment avec Java et utilisé pour Android et le serveur.

Langage développé pour les plateformes Apple et d'autres environnements, avec gestion moderne des types et de la mémoire.

Langage déclaratif de requêtes et de gestion de bases relationnelles, avec des dialectes propres aux systèmes.

Shell et langage de script employé pour lancer des commandes et automatiser des tâches sur des systèmes compatibles.

Format d'instructions binaire portable, conçu pour une exécution isolée et efficace dans divers hôtes.

Ensemble de fonctions, types ou ressources réutilisables qu’un programme appelle pour accomplir certaines tâches.

Structure et outils qui organisent le développement d’une application et en contrôlent souvent une partie du déroulement.

Composant s’insérant dans une chaîne de traitement pour appliquer une fonction transverse aux demandes ou réponses.

Structure destinée à transporter des données entre couches ou services sans porter nécessairement la logique métier.

Organisation des composants, de leurs responsabilités et de leurs interactions, avec les décisions structurantes du système.

Degré de dépendance entre éléments logiciels ; un couplage élevé rend souvent les changements plus difficiles.

Degré de proximité des responsabilités réunies au sein d'un module.

Découpage du système en parties dont les fonctions sont distinctes et compréhensibles.

Organisation favorisant des composants autonomes et remplaçables grâce à des interfaces définies.

Application déployée ou exécutée comme une unité principale, même si son code peut rester bien modulaire.

Application déployée comme un tout mais divisée en modules aux frontières et dépendances explicites.

Architecture répartissant un système en services autonomes communiquant par des interfaces, avec un coût opérationnel accru.

Modèle où un client demande des services à un serveur via un mécanisme de communication.

Organisation séparant les fonctions par niveaux, comme présentation, logique métier et accès aux données.

Conception isolant le cœur métier des interfaces techniques au moyen de ports et d'adaptateurs.

Famille de principes donnant au domaine et aux cas d'usage des dépendances dirigées vers l'intérieur.

Patron séparant données et logique applicative, présentation et traitement des interactions.

Patron où un modèle de présentation relie état et interface, souvent à l'aide de mécanismes de liaison de données.

Solution générale réutilisable à un problème de conception récurrent, à adapter plutôt qu'à copier mécaniquement.

Patron visant une instance partagée contrôlée ; il peut introduire de l'état global difficile à tester.

Construction qui centralise ou abstrait la création d'objets.

Patron traduisant une interface en une autre attendue par le code consommateur.

Patron où des abonnés sont notifiés lorsque l'état ou les événements d'un sujet changent.

Patron rendant plusieurs algorithmes interchangeables derrière une interface commune.

Abstraction regroupant les opérations d'accès aux entités ou agrégats persistés.

Composant portant une opération du domaine qui ne trouve pas naturellement place dans une entité.

Approche qui structure le logiciel autour des concepts métier et d'un langage partagé avec les spécialistes.

Objet du domaine identifié par une identité persistante plutôt que par ses seules valeurs.

Élément du domaine défini par ses propriétés plutôt que par une identité propre, souvent immuable.

Groupe cohérent d'objets métier traité comme une unité de cohérence autour d'une racine.

Frontière dans laquelle un modèle et un vocabulaire métier conservent une signification cohérente.

Coût futur des compromis de conception ou de maintenance ; toute dette n'est pas nécessairement accidentelle.

Modification de la structure interne du code visant à préserver son comportement observable.

Code existant dont l'évolution peut être difficile en raison de son ancienneté, de ses dépendances ou du manque de tests.

Solution récurrente susceptible de créer plus de problèmes qu'elle n'en résout dans un contexte donné.

Principe invitant à éviter la duplication des connaissances ou règles plutôt que toute répétition textuelle.

Principe consistant à éviter une complexité inutile pour le besoin réel.

Principe déconseillant d'implémenter aujourd'hui des fonctionnalités seulement hypothétiques.

Approche donnant des comportements par défaut cohérents pour réduire le paramétrage explicite.

Partie d'une application qui présente une interface et gère les interactions du côté utilisateur.

Partie qui assure des traitements serveur, l'accès aux données et d'autres services derrière une interface.

Pratique couvrant plusieurs couches d'une application, notamment interface, services et données.

Langage de balisage décrivant la structure et la sémantique d'une page web.

Langage de feuilles de style définissant présentation, disposition et adaptation visuelle d'un document.

Représentation arborescente et programmable d'un document utilisée par les navigateurs et scripts.

Composant du document défini par une balise ou un objet DOM, avec sa sémantique et ses attributs.

Information associée à un élément, par exemple alt, href ou lang.

Expression identifiant les éléments auxquels appliquer une règle de style.

Règle de priorité permettant de départager certaines déclarations CSS concurrentes.

Mécanisme combinant origines, couches, importance, spécificité et ordre pour choisir les styles appliqués.

Modèle CSS de mise en page adapté à la répartition d'éléments sur un axe principal et un axe transversal.

Modèle CSS de disposition selon des lignes et colonnes coordonnées.

Conception adaptant présentation et interactions aux dimensions et capacités des appareils.

Démarche construisant d'abord l'expérience des petits écrans avant de l'enrichir pour de plus grands.

Condition CSS appliquant des styles selon des caractéristiques du média ou de l'environnement.

Conception permettant au plus grand nombre d'utiliser un service, notamment avec aides techniques ou sans souris.

Recommandations internationales fournissant des critères de conformité pour l'accessibilité des contenus web.

Ensemble d'attributs décrivant rôles et états accessibles lorsque les mécanismes HTML natifs ne suffisent pas.

Unité réutilisable d'interface rassemblant rendu, propriétés et éventuellement comportement.

Ensemble des valeurs qui déterminent ce qu'une interface affiche et comment elle réagit.

Génération du HTML initial par un serveur avant son envoi au navigateur.

Génération importante de l'interface dans le navigateur à l'aide de JavaScript.

Production anticipée de pages prêtes à être servies sans rendu dynamique systématique à chaque requête.

Attachement, côté client, du comportement interactif à un HTML déjà produit, selon un framework.

Application web actualisant largement sa vue sans chargement complet d'une nouvelle page à chaque navigation.

Application web exploitant des capacités adaptées, comme installation ou service worker, selon le navigateur.

Script exécuté séparément de la page, capable notamment d'intercepter certaines requêtes et de gérer des tâches hors page.

Composant web s'appuyant sur des standards comme les éléments personnalisés et éventuellement le Shadow DOM.

Arbre DOM encapsulé permettant d'isoler en partie structure et styles d'un composant.

Représentation abstraite de l'interface utilisée par certains frameworks pour calculer des mises à jour.

Bibliothèque JavaScript de construction d'interfaces à base de composants et d'état.

Framework JavaScript d'interface utilisant composants, réactivité et modèles déclaratifs.

Framework web structuré proposant notamment injection de dépendances, composants et outillage intégré.

Outil de création d'interfaces transformant les composants lors de la compilation, avec un runtime adapté.

Outil qui analyse et rassemble ou transforme les ressources d'un projet afin de préparer leur diffusion.

Transformation de code source web vers une syntaxe ou une cible compatible avec les environnements visés.

Réduction de la taille du code diffusé en supprimant des informations non nécessaires à son fonctionnement.

Élimination du code exporté mais inutilisé lors d'une construction, lorsque l'analyse le permet.

Découpage du code en ensembles chargeables séparément pour réduire certains coûts de chargement.

Chargement différé d'une ressource ou d'un composant jusqu'à son utilisation probable ou effective.

Optimisations facilitant exploration, indexation et interprétation d'un site par les moteurs de recherche.

Programme qui construit et envoie des requêtes HTTP puis traite les réponses reçues.

Programme recevant des requêtes HTTP et renvoyant des réponses conformes au protocole.

Message envoyé par un client comprenant notamment méthode, cible, en-têtes et éventuellement corps.

Message du serveur comportant un code de statut, des en-têtes et éventuellement un corps.

Méthode HTTP destinée à récupérer une représentation sans demander de modification d'état au serveur.

Méthode HTTP soumettant des données à traiter ; son effet dépend du service et elle n'est pas intrinsèquement idempotente.

Méthode HTTP demandant la création ou le remplacement de l'état de la ressource ciblée par la représentation fournie.

Méthode HTTP appliquant une modification partielle à une ressource selon le format et les règles de l'API.

Méthode HTTP demandant la suppression de la ressource ciblée, avec une sémantique idempotente attendue.

Nombre à trois chiffres décrivant l'issue d'une requête, selon cinq classes principales.

Statut indiquant que la requête a réussi ; le contenu de la réponse dépend de la méthode.

Statut indiquant qu'une ou plusieurs ressources ont été créées après la requête.

Statut indiquant une opération réussie sans corps de réponse.

Statuts de redirection permanente ; 308 préserve la méthode HTTP lors de la redirection.

Statut signalant que le serveur ne peut ou ne veut traiter une requête considérée comme incorrecte.

Statut indiquant qu'une authentification valide est requise ou manquante, malgré son intitulé trompeur.

Statut indiquant que le serveur a compris la requête mais refuse de l'autoriser.

Statut indiquant que la ressource demandée est introuvable ou que le serveur ne souhaite pas révéler sa présence.

Statut indiquant un conflit avec l'état courant de la ressource, par exemple lors d'une mise à jour concurrente.

Statut indiquant que le client a dépassé une limite de fréquence définie par le serveur.

Statut générique signalant un dysfonctionnement inattendu du serveur.

Statut indiquant qu'une passerelle ou un proxy a reçu une réponse invalide d'un serveur amont.

Statut indiquant une indisponibilité temporaire, par exemple surcharge ou maintenance.

Champ de métadonnées d'une requête ou réponse, tel que Content-Type ou Authorization.

Partie éventuelle d'un message HTTP transportant une représentation ou des données.

En-tête indiquant le type de média d'un contenu et éventuellement son jeu de caractères.

Adresse identifiant l'emplacement d'une ressource et le moyen d'y accéder.

Identifiant normalisé d'une ressource ; une URL est une forme de URI donnant des indications d'accès.

Donnée placée dans la partie interrogative d'une URL, souvent utilisée pour filtrer ou paginer.

Valeur intégrée à un chemin d'URL pour identifier une ressource ou une partie de route.

Adresse ou point d'accès exposant une opération ou ressource d'un service.

Style architectural fondé sur des contraintes telles que ressources identifiées, interface uniforme et échanges sans état applicatif serveur par requête.

API conçue pour respecter, plus ou moins strictement, les principes REST ; le simple emploi de JSON et HTTP ne suffit pas.

Langage de requête et environnement d'exécution d'API permettant aux clients de sélectionner précisément des champs.

Cadre d'appels de procédures distantes s'appuyant notamment sur HTTP/2 et Protocol Buffers dans son fonctionnement habituel.

Mécanisme permettant à un programme de déclencher une opération exécutée dans un autre processus ou une autre machine.

Spécification décrivant contractuellement des API HTTP et permettant notamment documentation et génération d'outils.

Format textuel d'échange de données fondé sur objets, tableaux, chaînes, nombres, booléens et null.

Langage de balisage extensible représentant des données structurées dans un document textuel.

Langage de sérialisation de données lisible par l'humain, utilisé notamment pour la configuration.

Protocole permettant une communication bidirectionnelle persistante sur une connexion établie à partir d'une négociation HTTP.

Mécanisme HTTP envoyant un flux d'événements du serveur vers le navigateur, principalement dans un seul sens.

Notification envoyée par un service à une URL configurée lorsqu'un événement survient ; authenticité et répétitions doivent être gérées.

Mécanisme du navigateur encadrant l'accès JavaScript à des réponses provenant d'autres origines ; ce n'est pas un mécanisme d'authentification.

Règle de sécurité du navigateur restreignant certains accès entre documents ou scripts d'origines différentes.

Petite donnée associée à un domaine et transmise selon des règles de navigateur, souvent utilisée pour les sessions.

État logique reliant plusieurs requêtes d'un utilisateur, généralement à l'aide d'un identifiant ou d'un jeton.

Format compact de transmission de revendications signées ou éventuellement chiffrées ; son contenu n'est pas secret par défaut.

Découpage d'un ensemble de résultats en portions consommables successivement.

Pagination utilisant un repère opaque ou explicite plutôt qu'un simple numéro de page, adaptée à certains flux évolutifs.

Propriété selon laquelle répéter la même opération produit le même effet final visé qu'une seule exécution, hors effets annexes possibles.

Restriction du nombre d'opérations autorisées sur une période ou selon une autre règle de quota.

Délai maximum accordé à une opération avant l'arrêt de l'attente ou son signalement comme expirée.

Réexécution d'une opération après un échec présumé, à concevoir avec l'idempotence et les risques de doublons.

Politique augmentant progressivement le délai entre nouvelles tentatives, souvent avec une part aléatoire.

Ensemble organisé de données conçu pour être conservé, consulté et modifié selon des règles définies.

Logiciel gérant le stockage, les requêtes, la sécurité et l'intégrité d'une ou plusieurs bases de données.

Base organisant les données en relations, généralement représentées par des tables et interrogées avec SQL.

Catégorie de systèmes ne reposant pas principalement sur le modèle relationnel classique ; elle réunit des modèles variés.

Structure relationnelle représentant des lignes sous un ensemble de colonnes définies.

Ensemble de valeurs constituant une occurrence dans une table ou une collection.

Attribut d'une table défini par un nom, un type et éventuellement des contraintes.

Définition de la structure, des relations, types et contraintes des données.

Colonne ou groupe de colonnes identifiant de manière unique une ligne dans une table.

Colonne ou ensemble de colonnes reliant une table à une clé d'une autre table ou de la même table.

Règle interdisant certaines valeurs dupliquées dans une colonne ou un ensemble de colonnes.

Règle imposant qu'une colonne ne contienne pas la valeur SQL NULL.

Structure auxiliaire accélérant certaines recherches et tris au prix d'espace et de coûts de mise à jour.

Index construit sur plusieurs colonnes, dont l'ordre peut influencer l'utilisation par les requêtes.

Demande adressée au système de données pour lire ou modifier des informations.

Instruction SQL récupérant des lignes ou des résultats calculés à partir des données disponibles.

Instruction SQL ajoutant de nouvelles lignes à une table.

Instruction SQL modifiant des lignes existantes sélectionnées par les conditions indiquées.

Instruction SQL supprimant des lignes ; sans filtre adapté, elle peut cibler toutes les lignes.

Opération combinant des lignes de sources différentes selon une relation ou condition.

Jointure ne conservant que les combinaisons de lignes satisfaisant la condition de rapprochement.

Jointure conservant toutes les lignes de gauche, y compris en l'absence de correspondance à droite.

Calcul résumant plusieurs lignes, par exemple avec COUNT, SUM ou AVG.

Clause SQL regroupant des lignes pour calculer des agrégats par groupe.

Clause SQL filtrant des groupes après regroupement, à distinguer de WHERE appliqué aux lignes.

Requête intégrée dans une autre requête pour fournir une valeur, une liste ou une relation.

Représentation logique définie par une requête et consultable comme une table ; sa matérialisation éventuelle est distincte.

Résultat de requête stocké physiquement et actualisé selon une stratégie définie.

Groupe d'opérations traitées comme une unité de cohérence, validée ou annulée selon les garanties du système.

Ensemble de propriétés transactionnelles : atomicité, cohérence, isolation et durabilité.

Instruction validant les modifications d'une transaction.

Instruction annulant les modifications non validées d'une transaction dans les limites prévues par le SGBD.

Degré de séparation entre transactions concurrentes, déterminant les anomalies observables.

Gestion des conflits qui vérifie qu'aucune modification incompatible n'est intervenue avant validation.

Réservation ou blocage anticipé de ressources pour limiter certains conflits concurrents.

Outil associant objets applicatifs et tables relationnelles afin de faciliter certaines opérations de persistance.

Modification versionnée du schéma ou des données pour accompagner l'évolution d'une application.

Organisation des relations réduisant certaines redondances et anomalies de modification.

Introduction calculée de redondances pour améliorer des usages, notamment de lecture, avec des coûts de synchronisation.

Découpage logique ou physique de données selon des critères afin de faciliter leur gestion ou accès.

Maintien de copies de données sur plusieurs instances pour disponibilité, lecture ou reprise.

Répartition horizontale d'un ensemble de données entre plusieurs partitions ou serveurs distincts.

Copie récupérable de données et éventuellement de journaux permettant une restauration après incident.

Restauration d'une base à un instant choisi grâce à une sauvegarde et à des journaux adaptés.

SGBD relationnel embarqué stockant généralement une base dans un fichier et n'exigeant pas de serveur séparé.

SGBD relationnel libre proposant notamment transactions, SQL avancé, extensions et types spécialisés.

Système de données en mémoire souvent utilisé pour cache, files ou structures rapides, avec diverses options de persistance.

Instance d'exécution disposant d'un espace d'adressage et de ressources gérées par le système d'exploitation.

Séquence d'instructions exécutée dans un processus et partageant généralement sa mémoire avec d'autres threads du même processus.

Utilisation de plusieurs fils d'exécution au sein d'un programme.

Utilisation de plusieurs processus pour réaliser des travaux séparés ou parallèles.

Organisation de plusieurs tâches dont les périodes d'exécution se recouvrent, même sur un seul cœur.

Exécution effective de plusieurs calculs au même moment sur des ressources distinctes.

Modèle permettant à une tâche de suspendre l'attente d'une opération et à d'autres travaux de progresser.

Mécanisme distribuant événements et reprises de tâches selon une file ou un ordonnanceur.

Unité de calcul pouvant suspendre et reprendre son exécution en conservant son état.

Constructions syntaxiques marquant des fonctions et des points d'attente asynchrones dans plusieurs langages.

Objet représentant le résultat futur d'une opération asynchrone et son éventuel échec dans certains langages.

Abstraction représentant un résultat éventuellement disponible ultérieurement, avec des modalités propres à chaque environnement.

Unité de travail ordonnancée par un environnement asynchrone et pouvant généralement être attendue ou annulée.

Composant décidant quelles tâches ou unités d'exécution progressent à quel moment.

Défaut ou situation où le résultat dépend d'un ordre d'exécution concurrent non maîtrisé.

Accès concurrents non synchronisés à une même mémoire, avec au moins une écriture, selon un modèle mémoire précis.

Portion de code manipulant un état partagé qui nécessite un protocole d'accès coordonné.

Mécanisme permettant à un seul participant à la fois de détenir un verrou d'exclusion mutuelle.

Compteur de synchronisation limitant le nombre d'accès ou signalant des ressources disponibles.

Situation où des tâches attendent indéfiniment des ressources ou événements que les autres attendantes retiennent.

Situation où des tâches restent actives et réagissent sans faire progresser le travail utile.

Situation où une tâche est durablement privée des ressources nécessaires à sa progression.

Propriété d'une opération perçue comme indivisible par les autres participants selon un modèle donné.

Opération relevant d'un algorithme garantissant qu'au moins un participant progresse malgré la contention, sans garantie individuelle.

Mécanisme de transmission de travaux ou événements entre composants au moyen de messages stockés temporairement.

Service intermédiaire qui reçoit, oriente et redistribue des messages entre producteurs et consommateurs.

Modèle où des producteurs publient des événements sur des canaux auxquels s'abonnent des consommateurs.

Fait significatif déjà survenu dans le métier et communiqué à d'autres parties du système.

Organisation dans laquelle les composants réagissent à des événements plutôt qu'à des appels directs exclusivement.

Garantie donnant à certaines lectures une vue récente et coordonnée des écritures selon un modèle défini.

Garantie selon laquelle des copies convergent après arrêt des modifications, sans lecture immédiatement identique partout.

Résultat théorique sur les compromis d'un système distribué soumis à une partition réseau entre cohérence linéarisable et disponibilité des réponses.

Processus permettant à plusieurs nœuds de s'accorder sur une décision malgré certaines pannes.

Procédure sélectionnant un nœud pour coordonner des actions dans un groupe distribué.

Mécanisme interrompant temporairement des appels vers un service défaillant pour limiter les cascades d'erreurs.

Suite de transactions locales coordonnées avec, souvent, des actions compensatoires en cas d'échec.

Patron stockant dans la même transaction la modification métier et un événement à publier ultérieurement.

Garantie d'un traitement logique unique dans un périmètre défini, difficile à obtenir de bout en bout sans déduplication ou transactions.

Application créée avec des API et conventions propres à un système ou à une plateforme cible.

Application conçue pour fonctionner sur plusieurs systèmes à partir d'une base de code partiellement ou largement commune.

Programme destiné principalement aux ordinateurs personnels et à leurs systèmes d'exploitation.

Programme conçu pour les appareils mobiles, avec leurs interfaces et contraintes matérielles.

Interface utilisant fenêtres, boutons, panneaux et autres éléments visuels interactifs.

Interface pilotée par la saisie de commandes textuelles et d'arguments.

Interface interactive utilisant une grille de caractères dans un terminal.

Application affichant une interface de texte et transmettant généralement les entrées à un shell ou à un programme.

Interpréteur de commandes permettant de lancer des programmes et d'automatiser leur enchaînement.

Processus créé ou lancé par un autre processus, avec des liens de gestion dépendant du système.

Ensemble des techniques d'échange entre processus : tubes, sockets, mémoire partagée ou messages.

Point de communication logiciel utilisé pour échanger des données localement ou via un réseau.

Processus fournissant des services sans interface utilisateur principale, selon les conventions du système.

Composant ajouté à un logiciel hôte pour étendre son comportement via des points d'intégration prévus.

Emplacement où un programme autorise l'exécution de code externe ou personnalisable lors d'un événement.

Environnement restreignant l'accès d'un programme aux ressources et capacités du système.

Autorisations accordées à un logiciel pour accéder à des fonctions ou données protégées.

Signature cryptographique associant un artefact à une identité de publication et permettant d'en vérifier l'intégrité.

Procédure de contrôle et de validation de distribution imposée ou proposée par certaines plateformes, notamment Apple.

Programme préparant une application pour son utilisation sur un système en plaçant ses composants et réglages.

Mécanisme qui vérifie, télécharge et installe des versions nouvelles selon une politique définie.

Transformation des données conservées sur l'appareil pour les rendre compatibles avec une nouvelle version.

Échange de messages entre une interface web embarquée et le code natif de l'application hôte.

Composant intégrant le rendu d'un contenu web dans une application native.

Framework d'applications desktop réunissant notamment Chromium et Node.js pour distribuer des interfaces web.

Framework desktop qui associe un cœur natif, généralement Rust, à une interface rendue par la WebView du système.

Framework multiplateforme de développement d'interfaces et d'applications, principalement utilisé avec C++ ou Python.

Boîte à outils d'interface graphique libre utilisée sur Linux et d'autres systèmes.

Framework de création d'interfaces compilées pour diverses plateformes à l'aide de Dart.

Framework de développement d'applications mobiles utilisant React et des composants de plateforme.

Outils et API permettant de créer, compiler, tester et distribuer des applications Android.

Outils et API nécessaires au développement d'applications pour les appareils Apple concernés.

Format distribuant une application Linux dans un fichier autonome exécutable selon ses dépendances et contraintes.

Format et système de distribution d'applications Linux utilisant runtimes et mécanismes de sandbox.

Format de paquet et infrastructure de distribution applicative avec confinement selon la configuration.

Système conservant l'historique des changements de fichiers et facilitant comparaison, retour et collaboration.

Système distribué de gestion de versions qui organise l'historique autour de commits et de références locales ou distantes.

Ensemble de données de versionnement et de fichiers associés à un projet.

Copie du dépôt présente sur une machine, avec ses objets, références et état de travail.

Référence à un dépôt accessible ailleurs, fréquemment utilisé pour synchroniser une équipe.

Objet Git enregistrant un instantané et des métadonnées, notamment parent(s), auteur et message.

Empreinte identifiant un objet commit dans le dépôt ; sa longueur et son algorithme peuvent dépendre du format Git.

Référence mobile vers un commit permettant de faire évoluer plusieurs lignes de travail.

Référence désignant le commit courant, généralement par l'intermédiaire de la branche active.

Convention de nom pour une ligne de développement centrale ; Git n'impose pas ce nom.

État des fichiers extraits du dépôt, y compris leurs modifications locales.

Zone enregistrant la version des fichiers à inclure dans le prochain commit.

Commande plaçant des versions de fichiers ou modifications sélectionnées dans l'index.

Commande indiquant l'état du répertoire de travail et de l'index par rapport aux références du dépôt.

Commande montrant des différences entre fichiers, index ou commits selon les options.

Commande affichant l'historique des commits et les informations associées.

Commande créant une copie locale d'un dépôt existant et configurant généralement un dépôt distant.

Commande récupérant des objets et références distantes sans fusionner automatiquement ces changements dans la branche de travail.

Commande effectuant une récupération puis une intégration, par fusion ou rebasage selon la configuration.

Commande transmettant des références et objets locaux vers un dépôt distant autorisé.

Intégration des évolutions de plusieurs branches en conservant leur relation historique.

Rejeu d'une séquence de commits sur une autre base, ce qui crée généralement de nouveaux commits.

Situation où Git ne peut intégrer automatiquement des changements incompatibles et demande une résolution.

Application des changements d'un commit sélectionné sur la branche courante, en créant généralement un nouveau commit.

Commande créant un nouveau commit qui inverse les changements d'un commit antérieur, sous réserve de résolution possible.

Commande déplaçant une référence ou réinitialisant index et fichiers selon son mode ; certains usages détruisent des changements locaux.

Mécanisme enregistrant temporairement des modifications du répertoire de travail ou de l'index pour les réappliquer ensuite.

Référence nommée, souvent utilisée pour marquer une version publiée ; un tag annoté comporte des métadonnées propres.

Règles excluant de l'affichage habituel et de l'ajout automatique certains fichiers non suivis ; elles ne retirent pas les fichiers déjà suivis.

Proposition de changements soumise à discussion et vérification avant intégration sur une plateforme de collaboration.

Examen de changements par d'autres personnes pour identifier défauts et améliorer leur maintenabilité.

Copie d'un dépôt sur une plateforme permettant un développement indépendant puis d'éventuelles contributions.

Plateforme d'hébergement et de collaboration autour de dépôts Git, distincte du logiciel Git lui-même.

Plateforme de collaboration et de livraison logicielle autour de dépôts Git, proposée notamment en hébergement autonome.

Extension Git stockant les gros fichiers via des pointeurs suivis par Git et un stockage associé.

Dépôt référencé depuis un autre dépôt à une révision donnée, avec un cycle de synchronisation distinct.

Dépôt regroupant plusieurs projets ou composants dans une même histoire de versions.

Convention MAJOR.MINOR.PATCH : rupture de compatibilité d'API, ajout compatible puis correction compatible, une fois l'API définie.

Version identifiée comme antérieure à une publication stable, par exemple alpha, bêta ou candidate.

Document retraçant les modifications notables d'un produit entre ses versions.

Ensemble identifié d'artefacts, notes et révisions rendus disponibles pour une version donnée.

Activité visant à vérifier des comportements et à révéler des défauts à l'aide de contrôles définis.

Test ciblant une petite unité de comportement et maîtrisant généralement ses dépendances.

Test vérifiant l'interaction réelle de plusieurs composants ou systèmes.

Test parcourant un scénario utilisateur ou technique complet à travers les principales couches du produit.

Vérification d'un comportement attendu du point de vue de ses exigences et résultats.

Vérification qu'une modification n'a pas réintroduit un comportement précédemment corrigé ou dégradé l'existant.

Ensemble rapide de contrôles s'assurant que les fonctions principales sont utilisables après une modification ou livraison.

Contrôle de conformité aux critères permettant à une partie prenante d'accepter une fonctionnalité.

Vérification conduite directement par une personne sans exécution automatisée de l'ensemble du scénario.

Vérification exécutable de manière répétable par un outil et produisant un résultat exploitable.

Description des préconditions, actions et résultats attendus d'une vérification.

Données, objets ou environnement préparés pour fournir un contexte reproductible à des tests.

Objet de test reproduisant une interface en permettant notamment de vérifier les interactions attendues.

Remplacement minimal fournissant des résultats prédéterminés pour isoler un composant testé.

Implémentation simplifiée mais fonctionnelle d'une dépendance, par exemple un stockage en mémoire.

Terme générique pour un substitut de composant employé dans un test.

Substitut ou instrument qui enregistre les appels réalisés afin de permettre leur vérification.

Vérification explicite d'une propriété ou d'un résultat attendu ; son échec rend le test non conforme.

Mesure des portions de code parcourues par les tests, qui ne garantit pas leur capacité à détecter les bogues.

Proportion des issues de décisions exécutées par les tests selon l'outil de mesure.

Technique introduisant de petites modifications dans le code afin d'évaluer si les tests détectent ces altérations.

Approche générant de nombreuses entrées pour contrôler des invariants généraux d'un programme.

Soumission automatique de nombreuses entrées souvent imprévues pour identifier plantages et comportements anormaux.

Pratique de conception alternant test initial en échec, implémentation minimale et refactorisation.

Approche décrivant et vérifiant des comportements observables à partir d'exemples partagés.

Structure de scénario exprimant contexte, action et résultat attendu.

Modèle suggérant de répartir les tests entre vérifications rapides et ciblées et scénarios plus intégrés.

Test dont le résultat varie sans modification pertinente du code, souvent à cause du temps ou de dépendances externes.

Test conçu pour rendre les mêmes résultats dans des conditions initiales identiques.

Vérification des temps de réponse, débits et ressources sous des conditions définies.

Essai mesurant le comportement d'un système sous un niveau de sollicitations représentatif ou prévu.

Essai poussant le système au-delà de son fonctionnement normal pour observer ses limites et sa récupération.

Évaluation visant à identifier des défauts de confidentialité, d'intégrité, d'accès ou d'autres propriétés de sécurité.

Examen du code sans exécuter normalement le programme pour détecter des problèmes ou propriétés.

Outil signalant des erreurs potentielles, incohérences ou violations de règles dans le code.

Outil appliquant automatiquement une présentation standardisée du code source.

Outil analysant la compatibilité des types et la cohérence des annotations selon les règles prises en charge.

Ensemble de propriétés contextualisées telles que correction, lisibilité, fiabilité, sécurité et maintenabilité.

Défaut du logiciel provoquant un écart entre le comportement obtenu et celui qui était attendu.

Démarche d'identification, d'explication et de correction d'un défaut de programme.

Code ne respectant pas la grammaire du langage et souvent rejeté avant exécution.

Problème empêchant un compilateur de produire normalement l'artefact demandé.

Problème survenant pendant le fonctionnement du programme, comme un accès invalide.

Défaut de raisonnement ou de logique produisant un résultat incorrect malgré une exécution possible.

Liste des appels ayant conduit à un point d'échec, utile pour localiser son origine.

Emplacement ou condition suspendant le programme dans un débogueur.

Outil permettant d'inspecter l'état d'un programme, poser des points d'arrêt et contrôler son déroulement.

Mode d'exécution pilotée qui avance instruction par instruction ou appel par appel.

Fonction du débogueur affichant l'évolution d'une variable ou expression sélectionnée.

Production structurée ou textuelle de traces d'événements pendant l'exécution.

Catégorie de gravité ou de détail, comme debug, info, warning ou error.

Enregistrement de traces sous forme de champs exploitables, souvent sérialisés en JSON.

Valeur reliant plusieurs traces ou opérations appartenant à un même parcours de requête.

Observation continue de l'état et des indicateurs d'un service ou d'une application.

Capacité à comprendre l'état interne d'un système depuis ses signaux, notamment journaux, métriques et traces.

Mesure numérique agrégée ou ponctuelle du comportement d'un système.

Représentation d'une opération à travers plusieurs services au moyen de segments temporels reliés.

Unité d'une trace décrivant une opération, sa durée et ses relations avec d'autres opérations.

Déclenchement d'une notification lorsqu'une condition opérationnelle importante est détectée.

Arrêt inattendu d'un programme, d'un processus ou d'un composant.

Capture d'une partie de l'état mémoire et processeur d'un processus après un incident, potentiellement sensible.

Capacité à déclencher un défaut de façon contrôlée avec des étapes et conditions connues.

Recherche d'une révision responsable d'un défaut en testant progressivement des points de l'historique.

Recherche des mécanismes initiaux ayant permis un incident, au-delà de ses symptômes immédiats.

Retour documenté sur déroulement, causes, impacts et améliorations après une panne.

Cible mesurable fixée à un indicateur de fiabilité sur une période donnée.

Engagement contractuel définissant des niveaux de service et éventuellement des conséquences en cas de non-respect.

Mesure représentant une dimension du service, comme disponibilité ou latence réussie.

Processus transformant sources, dépendances et ressources en artefacts utilisables ou diffusables.

Fichier produit par une construction, comme exécutable, bibliothèque, archive ou image conteneur.

Construction visant des artefacts identiques à partir de sources et d'entrées identifiées, sous conditions contrôlées.

Outil automatisant des tâches de construction selon des règles de dépendance et des cibles.

Système générant des fichiers de construction pour différents outils et environnements, notamment en C et C++.

Outil de construction et d'automatisation largement utilisé dans les écosystèmes JVM et Android.

Outil de construction et de gestion de dépendances fondé notamment sur un modèle de projet XML pour la JVM.

Outil installant et résolvant des logiciels ou bibliothèques distribués en paquets.

Service hébergeant et distribuant les versions de bibliothèques et composants publiés.

Gestionnaire de paquets et écosystème de distribution associé à JavaScript et Node.js.

Outil d'installation de paquets Python depuis des index ou d'autres sources compatibles.

Outil Python gérant dépendances, environnements et publication à partir d'une configuration de projet.

Gestionnaire de paquets et outil de compilation officiel de l'écosystème Rust.

Paquet explicitement requis par un projet pour sa compilation ou son fonctionnement.

Paquet requis par une autre dépendance du projet plutôt que déclaré directement par lui.

Calcul d'un ensemble de versions satisfaisant les contraintes de compatibilité déclarées.

Fichier enregistrant les versions résolues afin de faciliter la reproductibilité des installations.

Fichier décrivant identité, configuration, scripts et dépendances d'un projet.

Environnement isolant notamment les installations de paquets d'un projet des autres environnements Python.

Outil permettant d'installer et sélectionner plusieurs versions d'un langage ou de son environnement.

Association nom-valeur fournie au processus par son environnement d'exécution.

Fichier conventionnel contenant des variables de configuration ; il peut renfermer des secrets et ne doit pas être diffusé sans précaution.

Adaptation des paramètres d'une application selon développement, test, préproduction ou production.

Commutateur de configuration permettant d'activer une fonctionnalité pour certains environnements ou utilisateurs.

Mise à jour de certains modules ou de l'interface pendant le développement sans redémarrage complet, selon l'outil.

Correctif publié rapidement pour résoudre un défaut important dans une version en service.

Source ou artefact produit automatiquement depuis une définition, un schéma ou un autre programme.

Outil créant une structure initiale de fichiers et configurations à partir de modèles.

Explications décrivant l'utilisation, les contrats ou les décisions d'implémentation d'un composant.

Document d'accueil présentant généralement l'objectif, l'installation et les premiers usages d'un projet.

Description des opérations exposées, paramètres, réponses, erreurs et conditions d'utilisation d'une interface.

Ensemble de pratiques rapprochant développement et exploitation afin d'améliorer livraison, fiabilité et retours opérationnels.

Pratique d'intégrer fréquemment les changements avec des contrôles automatisés, souvent déclenchés par les commits.

Pratique gardant le logiciel prêt à être publié grâce à un pipeline de validation et de préparation.

Mise en production automatisée de chaque changement satisfaisant les contrôles définis, sans validation manuelle systématique.

Enchaînement automatisé d'étapes telles que tests, construction, vérification et livraison.

Agent exécutant les tâches d'un pipeline d'automatisation.

Configuration employée pour créer et expérimenter le logiciel avant validation.

Environnement de validation visant à reproduire des caractéristiques pertinentes de la production.

Environnement réel dans lequel un service ou produit est utilisé par ses destinataires.

Installation ou mise à disposition d'une version logicielle dans un environnement cible.

Retour à une version antérieure ou à un état de fonctionnement connu, parfois complexe si les données ont changé.

Stratégie alternant deux environnements complets afin de basculer le trafic et faciliter un retour arrière.

Mise à disposition progressive d'une version à une fraction du trafic ou des utilisateurs avant généralisation.

Description versionnée de ressources d'infrastructure à l'aide de fichiers et d'outils d'automatisation.

Outil déclaratif de gestion d'infrastructures décrivant et appliquant un état souhaité via des fournisseurs.

Outil d'automatisation de configuration et de déploiement, souvent fondé sur des inventaires et playbooks.

Environnement d'exécution isolé au niveau du système d'exploitation, partageant généralement son noyau.

Ensemble de couches et métadonnées servant de modèle immuable de référence pour créer des conteneurs.

Écosystème d'outils permettant notamment de construire, diffuser et exécuter des images et conteneurs.

Fichier d'instructions décrivant les étapes de création d'une image de conteneur.

Outil décrivant et orchestrant plusieurs services conteneurisés avec une configuration déclarative.

Mécanisme conservant ou partageant des données au-delà du cycle de vie d'un conteneur donné.

Coordination du déploiement, des ressources, du réseau et du rétablissement de plusieurs conteneurs.

Plateforme orchestrant des charges conteneurisées au moyen de ressources déclaratives et de contrôleurs.

Plus petite unité déployable Kubernetes, contenant un ou plusieurs conteneurs partageant certaines ressources.

Abstraction donnant un point d'accès stable à un ensemble changeant de pods.

Ressource décrivant historiquement l'accès HTTP/HTTPS externe à des services ; son contrôleur et son évolution dépendent de la plateforme.

Gestionnaire de paquets Kubernetes utilisant des charts pour décrire et installer des ressources.

Service recevant des requêtes clientes puis les transmettant à des serveurs applicatifs en amont.

Composant distribuant des demandes sur plusieurs instances selon une stratégie.

Réseau de serveurs distribuant des ressources depuis des points proches des utilisateurs ou adaptés au trafic.

Ajustement automatique des ressources ou du nombre d'instances selon des métriques ou règles.

Vérification automatisée permettant de déterminer si une instance fonctionne ou peut recevoir du trafic.

Contrôle visant à détecter qu'un processus doit être redémarré lorsqu'il ne progresse plus.

Contrôle visant à déterminer si une instance est prête à servir des requêtes.

Service centralisant la conservation et l'accès contrôlé aux identifiants et autres secrets applicatifs.

Renouvellement d'un secret et mise à jour de ses consommateurs pour réduire les risques liés à sa durée de vie.

Procédures de conservation et de récupération des données et configurations après incident.

Ensemble de mesures permettant de rétablir les services après une défaillance majeure.

Ensemble des mesures visant à protéger un logiciel et ses données contre les usages ou accès non autorisés.

Ensemble des points accessibles par lesquels un système peut être sollicité ou compromis.

Analyse des actifs, acteurs, scénarios et mesures de protection dès la conception d'un système.

Attribution des permissions strictement nécessaires à une identité ou à un composant.

Vérification de l'identité revendiquée par un utilisateur, service ou autre acteur.

Détermination des actions qu'une identité reconnue a le droit d'effectuer.

Ensemble des règles et vérifications régissant l'utilisation des ressources protégées.

Modèle de contrôle d'accès fondé sur des rôles auxquels sont associés des droits.

Modèle de contrôle d'accès fondé sur des attributs du demandeur, de la ressource et du contexte.

Cadre de délégation d'autorisation permettant à une application d'obtenir un accès limité à des ressources protégées.

Couche d'identité construite sur OAuth 2.0 pour fournir notamment une authentification fédérée.

Élément présenté à une API pour exercer des permissions accordées, avec une portée et une durée de vie définies.

Élément permettant de demander de nouveaux jetons d'accès selon les règles du serveur d'autorisation.

Vérification d'identité combinant plusieurs facteurs indépendants, tels que possession et connaissance.

Identifiant d'authentification utilisant généralement la cryptographie à clé publique et les mécanismes FIDO.

Transformation à sens unique avec sel et algorithme adapté, comme Argon2id, pour vérifier sans stocker le mot de passe en clair.

Valeur aléatoire unique ajoutée avant hachage d'un mot de passe afin de contrer notamment les tables précalculées.

Transformation réversible de données en contenu illisible sans la clé appropriée, sous un schéma adapté.

Fonction produisant une empreinte de longueur définie conçue pour résister à certaines recherches et collisions.

Preuve cryptographique d'intégrité et d'origine liée à une clé privée, vérifiable avec les données correspondantes.

Protocole protégeant les communications réseau par chiffrement, intégrité et authentification selon son usage.

Ensemble des pratiques de création, stockage, distribution, rotation et révocation des identifiants sensibles.

Vérification que des données reçues respectent types, formats et règles métier avant utilisation.

Transformation de caractères spéciaux selon le contexte de destination pour empêcher leur interprétation comme du code.

Vulnérabilité où des données non fiables modifient la structure d'une requête SQL ; les paramètres liés sont une protection centrale.

Injection de contenu exécutable dans un contexte web consulté par d'autres utilisateurs, selon les vecteurs et protections.

Attaque amenant le navigateur authentifié d'une victime à envoyer une action non souhaitée à un site.

Vulnérabilité permettant à un attaquant de pousser un serveur à effectuer des requêtes vers des destinations non prévues.

Exploitation de chemins non maîtrisés pour accéder à des fichiers hors du périmètre autorisé.

Possibilité pour un acteur distant d'exécuter du code sur un système dans des conditions non prévues.

Reconstruction d'objets provenant de données non fiables pouvant provoquer exécution de code ou autres effets dangereux.

Ensemble des fournisseurs, dépendances, outils et étapes contribuant à la production et à la distribution d'un logiciel.

Inventaire structuré des composants logiciels présents dans un produit pour faciliter analyse et suivi des dépendances.

Examen des dépendances pour identifier leurs versions, licences et vulnérabilités connues.

Analyse statique orientée sécurité du code source ou de ses représentations sans exécuter l'application dans son fonctionnement normal.

Analyse dynamique d'une application en fonctionnement en la sollicitant pour détecter certaines vulnérabilités.

Identifiant public d'une vulnérabilité répertoriée dans le programme Common Vulnerabilities and Exposures.

Cadre de mesure de la gravité technique d'une vulnérabilité ; le score ne remplace pas l'analyse du contexte.

Processus coordonné de signalement et publication d'une vulnérabilité pour faciliter sa correction.

Modification destinée à améliorer une propriété mesurable, comme vitesse ou mémoire, sans dégrader les contraintes essentielles.

Mesure du comportement d'un programme afin d'identifier les parties consommant du temps ou des ressources.

Outil analysant l'utilisation du processeur, de la mémoire ou d'autres ressources par des appels et tâches.

Mesure comparative de performances dans des conditions reproductibles et documentées.

Durée entre une sollicitation et la réponse ou l'effet observé.

Quantité d'opérations ou de données traitées par unité de temps.

Temps écoulé entre réception d'une demande et production d'une réponse selon un périmètre défini.

Ressource ou étape qui limite la performance globale d'un processus.

Conservation temporaire de résultats ou données pour éviter une opération plus coûteuse.

Retrait ou remplacement de données en cache lorsque leur validité expire ou que la source change.

Accès pour lequel la donnée recherchée est trouvée dans le cache.

Accès pour lequel la donnée est absente du cache et doit être récupérée ou recalculée.

Période de validité définie pour une donnée ou un jeton avant expiration ; son sens dépend du système.

Chargement anticipé de données jugées susceptibles d'être utilisées prochainement.

Regroupement de plusieurs opérations pour réduire les coûts fixes de traitement ou de communication.

Technique qui attend une période sans nouvel événement avant de déclencher un traitement.

Technique qui plafonne le nombre d'exécutions d'un traitement sur une période.

Limitation du nombre d'éléments transmis par requête pour éviter une réponse excessive.

Ensemble de connexions réutilisables évitant de répéter des créations coûteuses.

Anti-pattern où une requête initiale entraîne une requête supplémentaire par élément récupéré.

Évaluation reportée d'une expression ou d'un calcul jusqu'au moment où son résultat est nécessaire.

Raffinement de performance réalisé avant de connaître les vrais besoins ou goulots, au risque d'accroître la complexité.

Zone temporaire stockant des données durant leur production, transformation ou transmission.

Traitement d'éléments au fur et à mesure de leur arrivée plutôt qu'après chargement intégral.

Mécanisme faisant ralentir un producteur lorsque le consommateur ne suit plus le rythme.

Augmentation de capacité par ajout d'instances ou de machines.

Augmentation de capacité par renforcement des ressources d'une instance.

Mesure de l'utilisation ou de la demande de calcul processeur, à contextualiser par rapport au nombre de cœurs.

Quantité de mémoire occupée ou attribuable à un programme selon la métrique choisie.

Amélioration de la stratégie d'accès aux données à partir des filtres, index et plans d'exécution.

Description des opérations choisies par un SGBD pour traiter une requête, parfois consultable avec EXPLAIN.

Ensemble des étapes menant de l'expression du besoin à la conception, réalisation, exploitation et retrait d'un logiciel.

Description de ce qu'un système doit accomplir pour répondre à un besoin.

Contrainte portant sur la qualité ou les conditions de service : performance, sécurité ou disponibilité, par exemple.

Document ou ensemble de règles précisant les comportements et contraintes attendus d'un système.

Condition vérifiable permettant de déterminer qu'une fonctionnalité répond à son besoin.

Formulation concise d'un besoin utilisateur servant de support à la discussion et à la validation.

Description des interactions entre un acteur et un système pour atteindre un objectif.

Liste ordonnée et évolutive des travaux envisagés ou retenus pour un produit ou une équipe.

Période de travail de durée fixe utilisée notamment dans Scrum pour atteindre un objectif défini.

Cadre de travail agile fondé sur des responsabilités, événements et artefacts pour gérer un produit complexe.

Méthode de gestion visuelle des flux favorisant la limitation du travail en cours et la fluidité.

Approche privilégiant adaptation, collaboration et livraisons itératives, sans imposer une unique méthode.

Cycle de travail aboutissant à une nouvelle version ou à un apprentissage exploitable.

Ajout intégré et potentiellement utilisable d'une capacité au produit existant.

Version suffisamment limitée pour tester des hypothèses essentielles auprès d'utilisateurs réels.

Réalisation exploratoire visant à éprouver une idée, une interface ou une faisabilité sans être forcément destinée à la production.

Expérimentation limitée démontrant la faisabilité d'une approche ou technologie.

Présentation évolutive des priorités, objectifs et étapes envisagés pour un produit.

Unité de suivi documentant une tâche, un défaut ou une demande avec son état et son contexte.

Élément enregistré dans un outil de suivi, tel qu'un problème, une suggestion ou un travail à réaliser.

Point de suivi correspondant à un objectif ou un ensemble de travaux à achever.

Évaluation incertaine d'un effort, d'une durée ou d'une complexité avant réalisation.

Critères partagés déterminant qu'un travail est considéré comme terminé au niveau de qualité convenu.

Pratique où deux personnes travaillent ensemble sur un même développement en partageant analyse et relecture.

Pratique de programmation collective où plusieurs personnes contribuent simultanément à un même problème.

Ensemble des informations nécessaires pour comprendre, installer, exploiter ou modifier un système.

Note documentant une décision de conception, son contexte, les options et ses conséquences.

Facilité relative à comprendre, corriger et faire évoluer un logiciel à coût maîtrisé.

Manque ou obsolescence de documentation augmentant le coût de compréhension et de maintenance.

Texte définissant les droits et obligations liés à l'utilisation, la modification et la redistribution du logiciel.

Logiciel dont la licence garantit notamment utilisation, étude, modification et redistribution selon les libertés établies.

Logiciel distribué sous une licence répondant aux critères de l'Open Source Definition, au-delà de la simple visibilité du code.

Logiciel distribué avec des droits limités par son titulaire ; le code source peut être inaccessible ou soumis à restrictions.

Modification, correction, documentation ou autre travail proposé à un projet, sous ses règles de collaboration.

Personne ou groupe chargé de l'évolution, de l'examen des contributions et souvent des publications d'un projet.