# Base de code

## Ce que c'est

Une base de code, codebase en anglais, parfois écrit en deux mots, code base, est l'ensemble du code source qu'une équipe modifie, revoit et livre comme un tout. Quand les ingénieurs parlent de « la base de code », ils désignent l'endroit où aboutit chaque changement d'une application : le code lui-même, ses tests, les scripts qui le construisent et le vérifient, les modifications de base de données et les documents qui expliquent comment les pièces s'assemblent.

La méthode [Twelve-Factor App](https://12factor.net/), destinée à construire des services web, donne la définition de travail la plus utile, car elle rend la frontière vérifiable. Dans un système de gestion de versions centralisé comme Subversion, une base de code est un dépôt. Dans un système distribué comme Git, c'est tout ensemble de dépôts partageant un commit racine, le premier de l'historique, celui qui n'a pas de parent. Deux dépôts issus du même premier commit constituent une seule base de code, quelle que soit l'ampleur de leur divergence. Deux dépôts commencés séparément sont deux bases de code, même s'ils contiennent des fichiers presque identiques.

Le même document associe cette définition à une seconde règle : une base de code, de nombreux déploiements. Chaque déploiement est une instance de l'application en cours d'exécution, et plusieurs coexistent généralement. La production en est une, la préproduction une autre, et la copie locale de chaque développeur compte aussi. Toutes exécutent la même base de code, souvent à des commits différents : un développeur a du travail que la préproduction n'a pas encore reçu, et celle-ci a du travail que la production n'a pas encore reçu.

Le contenu découle de cette définition. Le code source et tout ce qui permet d'en faire un programme opérationnel ont leur place dans la base, y compris un manifeste nommant chaque dépendance et sa version. Les dépendances elles-mêmes restent généralement à l'extérieur, récupérées par un gestionnaire de paquets. Les valeurs qui changent d'un déploiement à l'autre restent aussi dehors, et surtout les identifiants : un mot de passe enregistré une fois dans un commit accompagne ensuite chaque copie de l'historique.

Une base de code peut contenir plusieurs programmes. Un monorepo garde un frontend, une API et le code de base de données côte à côte dans un dépôt, pour qu'un seul commit puisse modifier les trois. Selon la règle du commit racine, cela reste une base de code. Le choix opposé répartit une application entre des dépôts aux historiques séparés, et chaque dépôt est alors sa propre base de code. Twelve-Factor est catégorique sur le résultat : plusieurs bases de code signifient un système distribué, dont chaque composant est une application à part entière.

## Pourquoi c'est important

La frontière décide de ce qui peut changer ensemble. Dans une base de code, une modification d'API et de l'écran qui l'appelle peut s'écrire, se revoir et se fusionner comme une unité. Entre deux bases de code, la même modification devient deux pull requests, deux publications et une période où un côté est en avance sur l'autre. Les deux approches fonctionnent ; leur prix dépend de l'endroit où la limite a été tracée.

La base de code est aussi l'unité d'application des règles. Une suite de tests, un linter, un outil de formatage, une règle de message de commit et un exécuteur de tâches prennent tous « la base de code » pour périmètre, et rien de ce qui reste à l'extérieur n'est contrôlé par eux.

Les décisions précoces se figent dans une base de code plus vite qu'ailleurs. Chaque ligne écrite après un choix le tient pour acquis : une règle de séparation en couches ou un niveau de qualité fixé dans les premières semaines donne donc sa forme à tout ce qui suit. Revenir dessus plus tard exige de réécrire le code construit autour de ce choix.

Pour les personnes, la base de code est ce que reçoit un nouveau membre de l'équipe. Si elle contient tout ce qu'il faut pour construire, tester et exécuter l'application, un clonage et une commande suffisent à démarrer. Si le savoir se partage entre le code et la mémoire de quelqu'un, la première semaine sert à découvrir ce qui se trouve où.

## À quoi cela ressemble en pratique

Go, TypeScript, SQL, Python et shell partagent le dépôt d'une plateforme, où
[la base de code est un monorepo polyglotte](/fr/portfolio/authored-578-go-task-automation-targets/)
et chaque langage arrive avec sa propre façon de construire, tester et exécuter le lint. La réponse a été un point d'entrée unique : une couche go-task passée à 578 cibles nommées, dont 50 dans le fichier racine et 528 dans des fichiers organisés en espaces de noms en dessous. Elle couvre les modes de développement natif, Docker et HTTPS, la qualité du code, la gestion de base de données et le déploiement. Chacun peut lancer `task --list` et voir toute la chaîne d'outils. Le nombre est aussi un avertissement : 578 cibles dépassent ce que quelqu'un peut garder en tête, et ce sont donc le nommage et les espaces de noms qui gardent l'ensemble utilisable.

Un autre projet a commencé par un dépôt vide le 25 novembre 2025, et
[trois décisions de ses premières semaines](/fr/portfolio/set-the-platforms-founding-technical-decisions/)
tenaient encore neuf mois et plusieurs milliers de commits plus tard : une pile en couches, l'accès aux données par des fonctions stockées et une exigence de zéro avertissement instaurée avant qu'il y ait beaucoup de code auquel l'appliquer. Le raisonnement derrière cette dernière décision est au cœur de cet article : une règle introduite au commit 5 000 est un projet de nettoyage, alors que la même règle au commit 50 est simplement la façon dont le dépôt fonctionne.

Les frontières internes d'une base de code peuvent constituer la conception elle-même. La
[contribution de la fondatrice à l'architecture dans le cadre de NextMariner](/fr/portfolio/a-maritime-platform-built-in-clean-layers/)
concerne une plateforme maritime construite en trois couches : le frontend Next.js ne s'occupe que de la présentation ; une API Go au rôle délibérément restreint, construite avec Huma sur Fiber, assure le routage, la validation et l'orchestration ; et la logique métier réside dans les fonctions PostgreSQL. Quand une règle change, elle change dans une seule couche, en SQL. Les frontières ont été documentées et imposées en revue, car une convention que personne ne fait respecter cesse d'en être une.

La base de code de ce site trace une autre frontière. Ses pages de projets sont écrites dans un dépôt séparé, exportées dans celui-ci par un script et enregistrées dans des commits, pour que le site se construise de façon autonome. Dans cette base de code, ces pages sont des fichiers générés, et les consignes de travail précisent qu'elles ne sont jamais modifiées à la main.

## Où les problèmes surviennent

### Le code copié diverge

Deux applications ont besoin de la même fonction auxiliaire, et le plus rapide est de la copier de l'une à l'autre. Un an plus tard, deux versions ont des corrections différentes, et un bug corrigé dans l'une reste présent dans l'autre. Twelve-Factor considère que plusieurs applications partageant le même code enfreignent sa règle et donne la solution : déplacer la partie commune dans une bibliothèque, l'importer par le gestionnaire de dépendances et laisser chaque base de code déclarer la version qu'elle utilise.

### Un secret entre dans l'historique

Un commit enregistre un fichier de configuration contenant une chaîne de connexion ou une clé d'API. Cette information reste dès lors dans l'historique que chaque clone emporte, même après la suppression de la ligne dans un commit ultérieur. Le test Twelve-Factor mérite d'être appliqué avant chaque commit : pourrait-on publier cette base de code en open source aujourd'hui sans exposer un seul identifiant ? Tout ce qui ferait échouer ce test appartient à l'environnement de chaque déploiement.

### Un fichier généré est modifié à la main

Un fichier écrit par un script ressemble à tout autre fichier source, et quelqu'un y corrige directement une faute. À l'exécution suivante, le script remet l'ancien texte et la correction disparaît sans un mot. Signalez clairement les chemins générés, gardez le générateur comme seul outil autorisé à les écrire et envoyez chaque correction vers ses données d'entrée.

### Les frontières internes s'effacent

Sous la pression d'une échéance, une requête de données est placée directement dans le gestionnaire d'une requête entrante parce que c'est le chemin le plus court, et les couches prévues au départ ne décrivent plus le code. Chaque raccourci est petit. Ensemble, ils transforment un changement de deux lignes en un changement qui touche toutes les couches. Une règle écrite aide, la revue aide davantage et un contrôle qui fait échouer la compilation quand une couche accède à l'intérieur d'une autre aide le plus.

### Une règle ne couvre que la moitié du code

Un linter installé pour le frontend laisse de côté les scripts shell et le SQL, et ces fichiers accumulent précisément les problèmes qu'il devait empêcher. Une exigence applicable à toute la base de code doit nommer chacun de ses langages : c'est le coût caché d'un dépôt polyglotte.

### Un fork lance un second produit

Une équipe copie un dépôt pour lancer un produit apparenté. Les deux copies gardent le même commit racine : selon Twelve-Factor, elles sont donc toujours une seule base de code, désormais au service de deux applications, et la divergence précédente commence à l'échelle d'un dépôt entier. Comparer les commits racine montre dans quelle situation on se trouve :

```sh
git -C app-a rev-list --max-parents=0 HEAD
git -C app-b rev-list --max-parents=0 HEAD
```

Une sortie identique indique une racine et une base de code communes ; des sorties différentes indiquent deux historiques séparés.

## Pour aller plus loin

- [I. Base de code](https://12factor.net/codebase)
  — la règle d'une base de code pour de nombreux déploiements et le test du commit
  racine partagé qui la sous-tend.
- [II. Dépendances](https://12factor.net/dependencies)
  — déclarer et isoler chaque dépendance dans un manifeste, pour que la base de code
  indique exactement ce qu'elle importe.
- [III. Configuration](https://12factor.net/config)
  — le test de publication en open source pour déterminer ce qui doit rester
  hors d'une base de code.
- [gitsubmodules](https://git-scm.com/docs/gitsubmodules)
  — comment Git intègre un dépôt dans un autre en laissant chacun garder
  son historique.
- [git-rev-list](https://git-scm.com/docs/git-rev-list)
  — la référence pour lister les commits, y compris les commits racine
  d'un historique.

<https://engineer.company/fr/glossary/codebase/>
