Modifiable ou immuable, quelle différence ?

Le principe de mutabilité versus immuabilité est un moteur des approches modernes, tant en développement logiciel qu’en gestion d’infrastructure.

La distinction peut être comparée à l’écriture d’un texte sur un tableau blanc. Si vous pouvez ajouter des mots, effacer des parties ou changer ce qui est écrit, cela s’apparente à une ressource mutable. Mais si le tableau blanc est scellé sous verre au moment où vous terminez et que vous devez utiliser un nouveau tableau blanc pour écrire autre chose, cela s’apparente à une ressource immutable.

Bien que ce concept s’applique de manière générale à l’informatique, il est le plus souvent rencontré en programmation. En programmation, comprendre quels types de données peuvent être modifiés directement versus quand une nouvelle copie doit être créée est essentiel pour les tâches courantes. Ces tâches comprennent l’écriture d’algorithmes, la création d’interfaces de programmation d’applications (API) et la conception de classes dans la programmation orientée objet (OOP).

Le choix d'utiliser des objets mutables ou immuables affecte la manière dont les données sont gérées en mémoire, la sécurité avec laquelle elles peuvent être partagées ou modifiées et la possibilité d'effets secondaires imprévus. C’est la raison pour laquelle mutable versus immuable est un concept fondamental pour les programmeurs débutants et expérimentés.

Par exemple, dans le langage de programmation Python, les listes et les dictionnaires sont des types mutables. Les éléments peuvent être ajoutés, supprimés ou modifiés dans ces objets. En revanche, les objets tels que les booléens (valeurs vraies ou fausses) ou les tuples (collections ordonnées telles que (1,2,3) sont des types immuables. Leur contenu ne peut pas être modifié ou muté sans créer un objet entièrement nouvel.

Le choix entre des données modifiables et des données non modifiables dépend généralement de trois facteurs clés : si les données ont besoin de mises à jour fréquentes, sont partagées entre les unités d’exécution ou nécessitent un historique des versions. 

Les types modifiables fonctionnent généralement mieux lorsque les données ont besoin de mises à jour fréquentes et que plusieurs parties d'un programme modifient le même objet.

Les objets modifiables modifient les données en place, réduisant ainsi la consommation de mémoire en évitant la création de nouveaux objets. Il peut réduire l’utilisation par le processeur de la récupération de place (le processus de suppression des données inutilisées pour libérer de la mémoire) car moins d’objets temporaires devront être créés et collectés.

Par exemple, les paniers d’achat dans les applications utilisent des listes modifiables pour ajouter ou supprimer des éléments directement sans créer de nouveaux objets pour chaque modification.

Les types modifiables sont plus performants avec des données qui changent fréquemment, comme les listes croissantes ou les compteurs en temps réel, car ils mettent à jour les objets existants plutôt que d’en créer de nouveaux. Cette efficacité accélère les opérations dans les structures de données qui reposent sur des modifications rapides.

Par exemple, la liste de lecture d'une application musicale peut utiliser une liste modifiable pour effectuer des mises à jour rapides. Il peut y avoir lieu en quelques microsecondes lorsqu’une musique est ajoutée ou supprimée, contre la création d’une liste de lecture de 1 000 chansons pour chaque modification.

Les objets modifiables permettent d'accéder à plusieurs parties d'un programme et de modifier le même objet. Ce processus leur permet de travailler avec un état partagé, c’est-à-dire les données que plusieurs composants lisent et écrivent pour coordonner leurs actions. Il est utile lorsque les composants doivent se coordonner ou communiquer via des données communes.

Par exemple, une application de gestion de projet utilise des objets modifiables pour partager des listes de tâches, des calendriers et des notifications. Lorsqu’un membre de l’équipe met à jour une tâche, tout le monde voit immédiatement la modification.

Les types non modifiables fonctionnent généralement mieux lorsque les données ne doivent pas changer après leur création. Cet aspect est particulièrement important dans les applications concurrentes, où plusieurs parties d’un programme accèdent aux mêmes données.

Étant donné que l’état d’un objet non modifiable est fixe, il ne sera pas modifié par un autre code. Cette fonctionnalité rend les programmes plus prévisibles et plus faciles à comprendre, car elle élimine les bugs liés aux mutations inattendues.

Par exemple, les applications bancaires stockent fréquemment les enregistrements de transaction sous forme d’objets non modifiables afin qu’aucun code ne puisse les altérer ultérieurement. C'est critique pour aider à assurer la conformité réglementaire et maintenir des traces d'audit qui prouvent que les transactions n'ont pas été altérées.

Les objets non modifiables sont généralement sécurisés par les unités d'exécution, car leur état ne peut pas changer après la création. Plusieurs unités d'exécution peuvent les lire en toute sécurité et simultanément sans conflits, bien que les développeurs doivent toujours gérer les références avec soin dans les systèmes concurrents. Il les rend idéaux pour les programmes unités d'exécution, où plusieurs unités d'exécution doivent accéder aux mêmes données sans provoquer de conflits.

Par exemple, une application peut exécuter des unités d'exécution simultanées pour les conditions météorologiques, le forecasting et les alertes. Le stockage des données météorologiques sous forme d'objets immuables permet à chaque fil de lire les mêmes informations sans risquer de les modifier de façon inattendue.

Les objets non modifiables peuvent simplifier le débogage, car les valeurs ne changent pas de manière inattendue pendant l’exécution du programme. Cette fonctionnalité peut réduire les bugs causés par des effets secondaires et aider les équipes à résoudre les problèmes plus rapidement.

Par exemple, les jeux vidéo stockent souvent la santé et les statistiques des joueurs sous forme d'objets non modifiables. Comme ces valeurs ne peuvent pas changer de manière inattendue, les développeurs peuvent facilement traquer les bugs en sachant qu’un code non lié n’altérera pas les statistiques.

Deux des styles de programmation les plus utilisés, la programmation orientée objet (OOP) et la programmation fonctionnelle, abordent la mutabilité différemment.

L’OOP favorise souvent la mutabilité, en créant des programmes autour d’objets qui contiennent à la fois des données et des comportements. Ces objets peuvent changer au fil du temps en utilisant des fonctions spéciales appelées positionneurs, qui peuvent mettre à jour la valeur d’une propriété (par exemple, changer l’âge d’une personne ou le prix d’un produit).

En revanche, la programmation fonctionnelle tend vers l'immuabilité. Il crée et renvoie de nouvelles valeurs chaque fois que quelque chose doit changer, ce qui rend les programmes plus prévisibles et plus faciles à tester.

Les langages de programmation varient également dans leur approche des types modifiables et non modifiables.

En Python, les types modifiables et non modifiables sont courants.

Les chaînes de caractères, c'est-à-dire les séquences de caractères telles que les noms ou les phrases, en sont un exemple. En Python, les chaînes de caractères ne sont pas modifiables. L'ajout d'un nouveau texte crée un nouvel objet chaîne. En revanche, les listes sont modifiables. Ces collections ordonnées sont itérables : vous pouvez ajouter, supprimer ou modifier des éléments dans l'objet de liste.

Au lieu d’utiliser un compilateur (un programme qui convertit le code en langage machine avant l’exécution) pour vérifier le code avant qu’il ne s’exécute, Python vérifie les types au moment de l’exécution. Cela signifie que les erreurs ne sont détectées que pendant l’exécution du programme. Les erreurs impliquant la mutation, comme la tentative de modification d’une chaîne non modifiable, déclenchent une TypeError.

Si l'erreur n'est pas traitée, le programme s'arrête immédiatement, empêchant l'exécution de tout autre code. Cette procédure permet un développement plus rapide mais nécessite une attention particulière à la manipulation des types.

Comprendre la mutabilité en Python permet d'éviter les erreurs lorsque vous partagez des données entre fonctions ou que vous travaillez dans un module partagé. Les tutoriels et les exemples de code disponibles sur GitHub présentent les bonnes pratiques d'utilisation des types intégrés de Python.

JavaScript utilise à la fois des types modifiables et des types non modifiables. Comme Python, les chaînes de caractères sont également non modifiables. Cependant, contrairement à Python, tous les objets sont modifiables par défaut.

La syntaxe flexible de JavaScript prend en charge les styles orientés objet et fonctionnels, ce qui permet aux développeurs de gérer la mutabilité selon les besoins.

Comme en Python, les chaînes Java ne sont pas modifiables. Une fois créée, la valeur d’une chaîne ne peut pas changer. Cette caractéristique peut être inefficace pour les programmes qui construisent ou modifient fréquemment le texte.

Pour résoudre ce problème, Java propose StringBuilder, une classe de chaîne modifiable qui permet de modifier directement le texte sans créer de nouveaux objets. Cela peut améliorer les performances et réduire l'utilisation de la mémoire, en équilibrant la sécurité de l'immutabilité et les avantages de la mutabilité en termes de performances.

C++ utilise le mot clé const pour marquer les variables, les fonctions et même les objets entiers en lecture seule. Il peut permettre aux développeurs de contrôler précisément la mutabilité, en transformant efficacement un objet modifiable en un objet non modifiable en empêchant les modifications.

Comme Java, les chaînes C++ peuvent être modifiables ou non, en fonction de leur implémentation.

C++ prend en charge les styles de programmation orientée objet et fonctionnel. Dans le style OOP, les développeurs modifient les objets existants au fil du temps, tandis que la programmation fonctionnelle crée de nouvelles valeurs au lieu de modifier les données existantes. 

Les principes de mutabilité et d’immuabilité s’étendent au-delà de la programmation, à l’infrastructure et aux systèmes. Les ingénieurs logiciels modernes appliquent ces mêmes concepts lorsqu'ils conçoivent des architectures cloud et des pipelines de déploiement.

L’infrastructure modifiable fait référence aux serveurs ou à d’autres ressources informatiques qui peuvent être modifiés après le déploiement. Par exemple, vous pouvez vous connecter à un serveur et mettre à jour manuellement un logiciel, modifier des configurations ou installer des correctifs. Bien que cette approche offre de la flexibilité, elle peut conduire à une dérive de la configuration où les serveurs deviennent des « flocons de neige » uniques et les modifications deviennent impossibles à suivre ou à reproduire.

L’infrastructure immuable signifie que les serveurs ou les ressources informatiques ne peuvent pas être modifiés après le déploiement. Au lieu de mettre à jour les systèmes en cours d'exécution, les équipes déploient de nouvelles instances avec des changements intégrés, puis retirent les anciennes. Cette approche réduit la dérive de configuration, simplifie la restauration et garantit des déploiements cohérents.

Les principes de mutabilité et d'immuabilité peuvent également s'appliquer à d'autres domaines de la conception de logiciels et de systèmes.

Certaines bases de données utilisent des journaux accessibles uniquement, ce qui signifie que chaque modification est enregistrée en permanence et ne peut pas être modifiée. D’autres sont modifiables, permettant des mises à jour ou la suppression directe de données, comme la modification d’un document.

Certains systèmes de stockage cloud peuvent être configurés en tant que stockage immuable afin de conserver les versions précédentes et de les verrouiller contre les modifications. Cela permet d’éviter que les données ne soient modifiées ou supprimées accidentellement. Le stockage modifiable permet de modifier ou de remplacer les fichiers à tout moment.

De nombreux outils de contrôle de version, tels que Git, suivent un modèle non modifiable, où chaque commit est enregistré dans un instantané distinct et non modifiable. Cela permet de garantir un historique fiable des versions, même lorsque de nouvelles modifications sont ajoutées.