Lexique · Code · 100 termes définis

Les mots du code.

Le vocabulaire du développement pour qui travaille avec des développeurs — ou avec une IA qui code : ce que chaque terme veut dire, et la décision qu'il cache.

Algorithme: Une suite d'étapes précises pour résoudre un problème — la recette avant le plat. Tout programme en est fait ; leur qualité se juge à la justesse d'abord, puis au coût (temps, mémoire) quand les données grossissent.
API: Application Programming Interface : le contrat par lequel un logiciel expose ses services à d'autres — requête entrante, réponse structurée. C'est la prise électrique du logiciel : standardisée, documentée, composable.
Authentification: Vérifier qui est là : mot de passe, lien magique, code, passkey. À ne jamais bricoler soi-même — les services dédiés (Supabase Auth, Auth0…) ont déjà payé le prix des pièges.

Back-end: Tout ce qui s'exécute côté serveur : données, règles métier, authentification, intégrations. Invisible quand il marche, décisif toujours — la robustesse d'un produit se joue là.
Base de données: Là où vivent les données : structurées, indexées, requêtables, sauvegardées. Le choix (relationnelle, document, clé-valeur) suit la forme des données — et Postgres est la réponse par défaut qui vieillit le mieux.
Bibliothèque (library): Du code prêt à l'emploi pour une tâche précise (dates, graphiques, animations) qu'on appelle depuis le sien. Différence avec le framework : la bibliothèque, c'est vous qui l'appelez ; le framework, c'est lui qui vous appelle.
Boilerplate: Le code de démarrage répétitif — configuration, structure, branchements — identique d'un projet à l'autre. Les frameworks et l'IA l'ont presque éliminé : on repart de plus haut, plus vite.
Branche et merge: Travailler en parallèle sans se marcher dessus : chaque chantier sur sa branche, fusionnée (merge) quand elle est prête. La discipline des branches courtes évite les fusions cauchemardesques.

Cache: Copie temporaire d'une ressource gardée au plus près de l'usage (navigateur, CDN, serveur) pour éviter de la recalculer ou de la retélécharger. L'art du cache tient en une question : combien de temps peut-on servir une version d'hier ?
CDN (content delivery network): Réseau de serveurs répartis qui rapproche vos fichiers de vos visiteurs : l'image servie depuis Paris plutôt que depuis l'Oregon. Des centaines de millisecondes gagnées sans toucher au code.
Chiffrement: Rendre les données illisibles sans la clé : en transit (HTTPS) et au repos (disques, sauvegardes). Non négociable — et distinct du hachage, qui lui ne se déchiffre pas.
CI/CD: Intégration et déploiement continus : à chaque changement, les tests tournent automatiquement ; s'ils passent, la mise en production peut suivre sans geste manuel. La différence entre déployer en tremblant et déployer en déjeunant.
CLI (ligne de commande): L'interface en texte : on tape des commandes, la machine répond. Austère et redoutablement efficace — l'outillage des développeurs y vit, et les agents IA s'y meuvent comme des poissons dans l'eau.
Cloud: Louer l'infrastructure à la demande — calcul, stockage, services — au lieu de posséder les machines. Élastique et facturé à l'usage : la liberté de commencer petit, et la discipline de surveiller la facture.
CMS headless: Gestion de contenu découplée de l'affichage : le contenu vit dans une API, le site le consomme et le met en forme librement. Les équipes éditent sans risquer la charte ; les développeurs changent de façade sans migrer le fond.
Code source: Le texte écrit par les développeurs, lisible et modifiable — par opposition au programme exécutable qui en découle. Posséder son code source, c'est posséder son produit : un point de contrat, pas un détail.
Commit: Une modification enregistrée dans l'historique, avec son message. Petit, cohérent, bien décrit : l'unité de travail lisible — six mois plus tard, c'est le message qu'on lit, pas le code.
Compilation: Traduire le code source en instructions exécutables par la machine. Certains langages compilent à l'avance, d'autres sont interprétés à la volée — pour le web, les bundlers compilent et optimisent tout le projet à chaque build.
Composant (UI): Brique d'interface autonome et réutilisable — bouton, carte, champ — avec ses variantes et ses états (repos, survol, focus, désactivé, erreur). Le design system est sa bibliothèque ; la cohérence, son dividende.
Conteneur (Docker): Empaqueter l'application avec tout son environnement : elle tourne identiquement partout — fini le « ça marche sur ma machine ». Kubernetes orchestre ensuite ces conteneurs à l'échelle, pour qui en a vraiment besoin.
Copilote: Assistant IA intégré à un outil de travail (code, écriture, tableur) : il propose, l'humain dispose. Le copilote augmente un métier existant ; l'agent exécute un processus — la frontière entre les deux est le niveau de supervision.
Core Web Vitals: Les trois métriques de performance perçue que Google mesure sur chaque page : LCP (vitesse d'affichage du contenu principal), INP (réactivité aux interactions) et CLS (stabilité visuelle). Elles pèsent dans le référencement et, surtout, dans l'abandon : chaque seconde de chargement se paie en visiteurs perdus.
Cron (tâche planifiée): Un déclencheur d'horloge : toutes les heures, chaque nuit, le premier du mois. La sync des reels de ce site tourne en cron — le tâcheron silencieux de tout back-end.
CSS: Le langage de présentation : mise en page, couleurs, typographies, animations. Moderne, il sait presque tout faire sans JavaScript — grilles, transitions, thèmes clair/sombre — et chaque kilo de JS évité se sent.

Debugging: Trouver pourquoi ça ne fait pas ce qu'on croit : reproduire, isoler, corriger, vérifier. Le vrai outil n'est ni le débogueur ni les logs — c'est l'hypothèse : que devrait-il se passer, et où diverge-t-on ?
Dépendances (npm): Les briques externes dont votre projet dépend, installées par un gestionnaire de paquets. Chacune est un gain de temps et un engagement : à maintenir, auditer, et savoir remplacer. Moins, c'est mieux.
Dette technique: Les raccourcis de code accumulés qui ralentissent chaque évolution future. Comme une dette financière : utile pour aller vite, fatale sans remboursement planifié. Le design a la sienne — écarts à la charte, composants dupliqués, états oubliés.
DNS: L'annuaire d'Internet : il traduit kevinchau.fr en adresse de serveur. Les enregistrements (A, CNAME, MX…) routent le site et les emails — et sa propagation explique les « ça marche chez moi mais pas chez toi » des migrations.
Documentation: Ce qui permet à quelqu'un d'autre — ou à soi-même dans six mois — de comprendre et d'utiliser le code : README, guides, référence d'API, décisions d'architecture. Un livrable, pas une politesse ; je l'inclus dans chaque passation.
DOM: Document Object Model : la représentation vivante de la page dans le navigateur, que JavaScript manipule. Chaque modification a un coût — les frameworks passent leur vie à en optimiser l'accès.

Edge computing: Exécuter le code au plus près de l'utilisateur, dans les points de présence du réseau plutôt que dans un unique data center. Des millisecondes gagnées sur chaque requête — précieux pour la personnalisation et les redirections.
Environnements (dev, staging, prod): Les étages du déploiement : développement (chez soi), staging (répétition générale sur données proches du réel), production (les vrais utilisateurs). On ne teste pas en production — sauf qu'on le fait toujours un peu, d'où les feature flags.

Feature flag: Un interrupteur qui active une fonctionnalité sans redéployer : test sur 5 % des utilisateurs, lancement progressif, coupure instantanée en cas de souci. Le déploiement découplé de l'exposition.
File d'attente (queue): Découpler ce qui doit être fait de quand on le fait : les tâches s'empilent, des travailleurs les traitent au rythme possible. L'amortisseur des systèmes — emails, exports, traitements lourds.
Framework: Un cadre qui structure l'application et fournit les briques communes : routage, rendu, données. Il impose des conventions — c'est sa valeur : moins de décisions à réinventer, plus de terrain balisé. Next.js, Django, Rails en sont.
Front-end: Tout ce qui s'exécute chez l'utilisateur : l'interface, ses interactions, sa vitesse perçue. C'est la partie visible du produit — et celle où design et code fusionnent. Mon terrain de jeu principal.
Full-stack: Couvrir front-end et back-end. Le terme fait débat (peut-on tout maîtriser ?) mais l'époque lui donne raison : les outils modernes — et l'IA — permettent à une petite équipe, voire une personne, de livrer un produit entier.

Gestion des secrets: Clés d'API, mots de passe, jetons : jamais dans le code ni dans Git — dans des variables d'environnement ou un coffre, avec rotation en cas de doute. Une clé qui a transité en clair est une clé à changer.
Git: Le système de contrôle de version : chaque changement est historisé, comparable, réversible. Le filet de sécurité fondamental du code — et la mémoire du projet, si les messages de commit racontent le pourquoi.
GraphQL: Un langage de requête pour API : le client décrit exactement les données qu'il veut, en une seule requête. Puissant pour les interfaces complexes ; surdimensionné pour un site éditorial — REST suffit souvent.

Hachage de mots de passe: On ne stocke jamais un mot de passe : on stocke son empreinte irréversible (bcrypt, argon2). En cas de fuite, les mots de passe restent illisibles — c'est le minimum légal et moral.
Haute disponibilité: Rester en ligne malgré les pannes : redondance, basculement automatique, absence de point unique de défaillance. Se chiffre en « neufs » (99,9 %…) — chaque neuf supplémentaire coûte un ordre de grandeur.
Hébergement: Où le site vit : serveur mutualisé, VPS, cloud, plateforme spécialisée. Le choix arbitre coût, contrôle et confort d'exploitation — ce site tourne en Node.js chez Hostinger, build autonome.
HTML: Le langage de structure du web : titres, paragraphes, liens, formulaires. Sémantique avant tout — un HTML bien balisé est lisible par les navigateurs, les lecteurs d'écran et les moteurs, IA comprises. Le SEO commence ici.
HTTPS / TLS: Le chiffrement du trafic web : personne entre le navigateur et le serveur ne peut lire ni altérer l'échange. Obligatoire partout depuis longtemps — les certificats sont gratuits et automatiques.
Hydratation: Le moment où le HTML envoyé par le serveur devient interactif : le JavaScript « prend » sur la page déjà affichée. Mal gérée, elle fait cliquer dans le vide — d'où la course aux architectures qui en envoient moins.

Injection SQL: Glisser du code malveillant dans un champ de formulaire pour manipuler la base. Le classique des classiques — neutralisé par les requêtes paramétrées, et la raison de ne jamais concaténer une entrée utilisateur dans une requête.

JavaScript: Le langage d'interaction du web, seul à s'exécuter nativement dans le navigateur — et désormais partout (serveurs, apps, outils). Sa règle d'or côté site : en charger le moins possible ; le meilleur JavaScript est celui qu'on n'envoie pas.

Langage de programmation: La langue dans laquelle on écrit les instructions : JavaScript, Python, Swift… Le choix engage moins la performance qu'on croit et beaucoup plus l'écosystème : bibliothèques disponibles, facilité de recruter, longévité.
Legacy (code hérité): Le code ancien qui fait tourner l'existant : mal documenté, risqué à toucher, mais en production. On ne le méprise pas — il rapporte l'argent. On l'encercle de tests, puis on le remplace morceau par morceau.
Licence logicielle: Le contrat d'usage d'un code : permissive (MIT — presque tout est permis), copyleft (GPL — les dérivés doivent rester libres), propriétaire. À vérifier avant d'intégrer une dépendance dans un produit commercial.
Linter: L'outil qui relit le code en continu : erreurs probables, style incohérent, pièges connus. Impersonnel et infatigable — les débats de style se règlent une fois dans la configuration, plus jamais en revue.
Logs: Le journal de bord de l'application : ce qui s'est passé, quand, avec quelles données. Illisibles en vrac, précieux structurés — quand l'incident survient, on ne peut interroger que ce qu'on a noté.

MCP (Model Context Protocol): Protocole ouvert qui standardise la connexion entre assistants IA et outils externes (fichiers, bases, API) : un serveur MCP expose des capacités, tout client compatible peut s'en servir. L'USB-C de l'outillage des agents.
Micro-services: Découper l'application en services indépendants qui communiquent par API. Résout des problèmes d'échelle d'organisation — et en crée de coordination : pour une petite équipe, le monolithe bien rangé gagne presque toujours.
Migration (de schéma): Un changement versionné de la structure de la base : ajouter une table, une colonne, une contrainte. Écrites, relues et rejouables, les migrations sont l'historique officiel de vos données — ce projet en compte onze.
Monitoring et alerting: Surveiller la santé du système (erreurs, latence, saturation) et réveiller quelqu'un quand un seuil casse. La différence entre apprendre l'incident par ses outils ou par ses clients.
Monolithe: Toute l'application dans une seule base de code déployée d'un bloc. Injustement démodé : simple à développer, tester et déployer — le bon choix par défaut, jusqu'à preuve chiffrée du contraire.
MVP (Minimum Viable Product): Un MVP (Minimum Viable Product) est une version minimaliste, mais fonctionnelle d'un produit, d'une interface ou d'un service. Il permet :; Recueillir les avis sur cette première version permettra d'orienter efficacement le développement et les améliorations futures du produit fini de manière itérative.; C'est une stratégie pour connaître votre cible, son utilisation du produit, le tout rapidement et à moindre coût.

Next.js: Le framework React pour le web : rendu serveur, routage, optimisations intégrées. Mon choix par défaut pour les sites exigeants — ce site en est un, App Router et server components compris.
No-code / low-code: Construire sans (ou avec peu de) code : formulaires, automatisations, sites, apps internes. Parfait pour valider vite et outiller les équipes — les limites arrivent avec l'échelle, l'intégration fine et la propriété des données.
Node.js: JavaScript côté serveur : le même langage du navigateur au back-end. C'est lui qui fait tourner l'outillage du web moderne — et ce site, sur son hébergement.
Nom de domaine: Votre adresse sur le web — un actif de marque à part entière : renouvelé sans faute, possédé en propre (jamais au nom d'un prestataire), protégé des variantes gênantes.

OAuth / SSO: Se connecter via un compte existant (« Continuer avec Google ») ou un identifiant d'entreprise unique. Moins de mots de passe, moins de friction — et la responsabilité de l'identité déléguée à qui sait la porter.
Open source: Du code publié sous licence libre : chacun peut le lire, l'utiliser, le modifier. L'infrastructure du web entier repose dessus — et sa maintenance repose sur des équilibres fragiles qu'il faut soutenir (financement, contributions).
ORM: Object-Relational Mapping : manipuler la base via les objets du langage plutôt qu'en SQL brut. Confortable et productif — jusqu'à la requête complexe où le SQL direct redevient l'outil juste.

Pair programming: Coder à deux sur le même écran : l'un écrit, l'autre pense. Coûteux en apparence, rentable sur le difficile — et le duo humain-IA en est la version moderne : l'IA tient le clavier, l'humain tient le cap.
Post-mortem: L'analyse à froid d'un incident : chronologie, causes, remèdes — sans chasse au coupable. Les systèmes s'améliorent par leurs pannes documentées ; les équipes aussi.
Pull request (revue de code): Proposer ses changements à la relecture avant fusion : un pair lit, questionne, approuve. Le meilleur outil de qualité et de transmission d'une équipe — et le garde-fou naturel du code généré par IA.
PWA (progressive web app): Site web qui se comporte comme une application : installable, capable de fonctionner hors ligne, notifications. Le meilleur des deux mondes quand le passage par les stores ne se justifie pas.

Rate limiting: Limiter le nombre de requêtes par utilisateur et par période : contre les abus, les robots et les factures. Toute API publique en a besoin — le chatbot de ce site est limité par IP et par heure.
React: La bibliothèque d'interfaces dominante : l'écran se décrit en composants qui se re-rendent quand les données changent. Son écosystème est sa force ; sa complexité accumulée, son procès permanent.
Refactoring: Améliorer la structure du code sans changer son comportement : renommer, extraire, simplifier. L'entretien courant qui évite la dette technique — invisible au client, vital au produit.
REST: Le style d'API le plus répandu : des ressources adressées par URL, manipulées par les verbes HTTP (GET pour lire, POST pour créer…). Simple, cacheable, universellement compris.
Revue de code par IA: Faire relire chaque changement par un modèle avant l'humain : bugs probables, failles, incohérences. Un second regard infatigable — qui complète la revue humaine sans la remplacer : l'IA voit le code, l'humain voit le contexte.
RLS (row level security): La sécurité au niveau de la ligne, dans la base même : chaque requête ne voit que les données autorisées pour l'utilisateur courant. La défense en profondeur de ce site — même un bug applicatif ne fait pas fuiter les données d'autrui.
Rollback: Revenir à la version précédente quand la nouvelle déraille. Sa vraie mesure est le temps : un rollback en une minute change la culture — on ose davantage quand on sait reculer vite.

Sauvegarde (backup): La copie qui sauve quand tout brûle — à condition d'être automatique, externalisée et testée : une sauvegarde jamais restaurée est une superstition. La question n'est pas « si » mais « quand » elle servira.
Scalabilité: La capacité à encaisser la croissance sans réécrire : plus d'utilisateurs, de données, de trafic. Verticale (plus grosse machine) ou horizontale (plus de machines) — et souvent prématurée : le goulot réel est rarement celui qu'on avait prédit.
SDK: Software Development Kit : la boîte à outils fournie par une plateforme pour s'intégrer avec elle — bibliothèques, exemples, documentation. Un bon SDK fait gagner des semaines ; son absence en fait perdre autant.
Sécurité de la chaîne d'approvisionnement: Vos dépendances sont du code que vous exécutez : un paquet compromis compromet tout. Réflexes : épingler les versions, verrouiller (lockfile), auditer, se méfier des paquets miracles publiés hier.
Serverless: Exécuter du code sans gérer de serveurs : des fonctions qui s'invoquent à la demande et se facturent à l'usage. Idéal pour l'événementiel et les charges irrégulières — attention aux démarrages à froid et aux factures surprises.
Serveur: La machine (ou le service) qui répond aux requêtes. De moins en moins un objet physique qu'on bichonne, de plus en plus une ressource qu'on déclare — mais quand « le serveur est tombé », l'abstraction redevient très concrète.
Sessions et tokens: Comment le serveur se souvient de vous entre deux requêtes : un identifiant de session ou un jeton signé (JWT) présenté à chaque appel. Leur durée de vie et leur stockage sont des décisions de sécurité, pas des détails.
SPA (single-page application): Une application web qui charge une page unique puis navigue sans rechargement. Fluide pour les outils connectés ; contre-productive pour un site éditorial, où le rendu serveur sert mieux vitesse et référencement.
Sprint (agile): Cycle court (une à quatre semaines) qui se termine par un incrément livrable et une rétrospective. Le rythme compte plus que la durée : livrer souvent, apprendre souvent.
SQL: Le langage des bases relationnelles, cinquante ans et toujours souverain : décrire ce qu'on veut, laisser le moteur trouver comment. Le NoSQL a ses niches (documents, échelle extrême) — mais on revient toujours à SQL.
SSR / SSG (rendu serveur et statique): Deux façons de servir des pages rapides : générées à la demande sur le serveur (SSR) ou pré-construites à l'avance (SSG). Dans les deux cas, le visiteur reçoit du HTML prêt — bon pour la vitesse perçue comme pour le référencement.
Stack technique: L'ensemble des technologies d'un produit : langage, framework, base de données, hébergement, services. Une bonne stack est ennuyeuse : des briques éprouvées, qui se recrutent, assemblées simplement. Ce site : Next.js, Tailwind, Supabase, Hostinger.

TDD: Test-Driven Development : écrire le test avant le code, le voir échouer, puis coder jusqu'au vert. Moins une religion qu'une hygiène : réfléchir au comportement attendu avant de foncer.
Temps réel (WebSocket): Une connexion qui reste ouverte : le serveur pousse les nouveautés sans que le client demande — chat, curseurs partagés, cours de bourse. À réserver aux vrais besoins : le temps réel coûte en complexité.
Test d'intrusion (pentest): Payer un attaquant bienveillant pour trouver les failles avant les autres : méthode, périmètre, rapport, correctifs. Complément humain des scanners — certains contextes (santé, finance) l'exigent contractuellement.
Tests end-to-end: Tester le parcours complet comme un utilisateur : ouvrir la page, cliquer, remplir, vérifier. Plus lents et plus fragiles que les tests unitaires — on en met peu, sur les parcours qui font vivre le produit.
Tests unitaires: Vérifier automatiquement chaque brique isolée : cette fonction, avec ces entrées, rend ce résultat. Rapides, nombreux, ils transforment la peur de casser en simple feu rouge/vert.
TypeScript: JavaScript typé : chaque donnée déclare sa forme, les erreurs se voient à l'écriture plutôt qu'en production. Le standard de fait des projets sérieux — et un filet de sécurité précieux quand une IA écrit une partie du code.

Versionnage sémantique (semver): Numéroter les versions en trois chiffres — majeure.mineure.correctif — où la majeure annonce les ruptures. Une convention de politesse entre logiciels : elle dit ce qu'une mise à jour risque de casser.
Vibe coding: Construire un logiciel en dialoguant avec une IA de code : on décrit, on regarde, on corrige — l'aller-retour remplace la spécification. Sous contraintes réelles, la rigueur ne disparaît pas : elle se déplace au moment où l'idée devient une expérience. Le jugement reste le métier.
Vulnérabilité (CVE): Une faille référencée publiquement, avec sa gravité. L'hygiène : connaître ses dépendances, appliquer les correctifs vite — la plupart des piratages exploitent des failles déjà corrigées ailleurs.

Webhook: L'API à l'envers : au lieu d'interroger un service en boucle, c'est lui qui vous appelle quand un événement survient — paiement validé, formulaire soumis. La colle des automatisations.

XSS: Cross-Site Scripting : injecter du script dans une page vue par d'autres (commentaire piégé, par exemple). Parade : échapper toute donnée affichée, politique de sécurité de contenu (CSP) — le framework aide, la vigilance reste.

Les mots posés, place aux actes : sites et applications, du design au déploiement.

Voir les services →