Glossaire du développement

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

Fixation de certains arguments d'une fonction afin d'en créer une autre plus spécialisé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.

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.

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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éférence mobile vers un commit permettant de faire évoluer plusieurs lignes de travail.

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

Instruction validant les modifications d'une transaction.

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.

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

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

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

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.

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

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.

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

Identifiant utilisé pour retrouver une valeur dans une table associative ou une structure de 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.

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 isolant notamment les installations de paquets d'un projet des autres environnements Python.

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Fonction prenant une fonction comme argument ou renvoyant une fonction.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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é.

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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.

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

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

Instruction SQL ajoutant de nouvelles lignes à une table.

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

É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.

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Valeur ou expression sur laquelle agit un opérateur.

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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.

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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é.

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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.

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

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

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

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

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

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

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.

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

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

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

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

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

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