La rétrocompatibilité (backward compatibility) est la garantie qu'une nouvelle version d'un logiciel, d'une API ou d'une librairie n'invalide pas ce qui fonctionnait avec la précédente : le code écrit hier continue de tourner aujourd'hui, sans modification. C'est elle qui transforme une mise à jour en non-événement — ou son absence qui la transforme en projet de migration.
Additif Par Défaut
La discipline tient en une règle : ajouter plutôt que modifier. Un paramètre optionnel avec valeur par défaut plutôt qu'une nouvelle signature, une dépréciation annoncée plutôt qu'une suppression sèche, un changelog qui dit explicitement ce qui change du point de vue du consommateur. Le versioning sémantique encadre le tout : une rupture exige une version majeure.
Un Coût Asymétrique
Maintenir la compatibilité coûte une fois, au mainteneur. Casser coûte autant de fois qu'il y a de consommateurs — migration, coordination, risque que certains s'enferment sur une version figée. Plus un code est partagé, plus l'arbitrage penche vers la compatibilité : la confiance dans une dépendance se construit release après release et se détruit en une seule.
Où elle se joue
La rétrocompatibilité ne concerne pas que les éditeurs de librairies. Dans une application métier, elle se joue à plusieurs frontières :
- Une API consommée par d'autres — application mobile, partenaire, autre service interne. On ne contrôle pas le rythme de mise à jour de ses clients.
- Une librairie interne partagée entre plusieurs applications : chaque rupture se paie une fois par projet.
- Le schéma de base de données pendant un déploiement — lors d'un rolling update, l'ancienne et la nouvelle version du code tournent en même temps sur la même base.
- Les messages asynchrones — un message mis en file par l'ancienne version peut être consommé par la nouvelle, et inversement.
- Les fichiers d'import et d'export qu'un client a intégrés dans ses propres outils.
Comment je la pratique
- Migrations de base en deux temps — on ajoute la nouvelle colonne, le code écrit dans les deux, puis on retire l'ancienne dans une livraison ultérieure, une fois plus aucune version en service ne la lit.
- Paramètres optionnels — un besoin nouveau s'ajoute avec une valeur par défaut qui conserve le comportement actuel.
- Dépréciations annoncées — l'ancien chemin continue de fonctionner, signale son remplacement, et disparaît à la version majeure suivante.
- Un changelog écrit pour le consommateur — « nouveau paramètre optionnel, les appels existants ne changent pas » est une information actionnable ; « refacto du bridge » n'en est pas une.
Un exemple mesuré
Pour Orange, je maintiens une librairie PHP interne partagée entre cinq applications Symfony. En trois ans et vingt-sept versions publiées, l'API du quotidien n'a connu qu'un seul changement cassant — un renommage de classe et un déplacement de méthode, accompagnés d'un guide de migration en deux remplacements. Conséquence directe : deux applications consomment la version 4, trois vivent encore très bien en version 3, et personne n'a été forcé de migrer. Monter de version est un non-événement, et c'est précisément pour cela que les équipes finissent par le faire.
Le même raisonnement s'applique aux déploiements de ces applications, qui se font en pleine journée par rolling update : pendant quelques minutes, deux versions cohabitent, et chaque migration de schéma doit être additive pour que l'ancienne continue de fonctionner.
Les pièges
- Considérer qu'un changement « mineur » est sans risque : rendre obligatoire un champ jusqu'ici optionnel, ou durcir une validation, casse des intégrations.
- Garder la compatibilité indéfiniment : sans calendrier de retrait, les chemins dépréciés s'accumulent et deviennent de la dette.
- Découvrir les ruptures par la CI du consommateur plutôt que par le changelog du producteur.
Une dépendance dont les mises à jour sont des non-événements finit toujours à jour ; une dépendance qui casse finit épinglée sur une vieille version — c'est-à-dire abandonnée sans que personne ne l'ait décidé.
Le retour d'expérience complet est dans partager du code entre cinq applications sans les coupler. Tenir cette discipline dans la durée fait partie de ma prestation de maintenance et évolution d'applications web.