Comprendre le concept d’immutabilité des données

En informatique, l’immutabilité est un concept clé lorsque l’on parle de stockage et de traitement des données, et c’est également un concept que l’on retrouve en programmation.

Une donnée immutable (appelée immuable en français), est une donnée qui ne pourra pas muter, c’est à dire qu’elle ne pourra jamais être modifiée.

Parfois même, cette donnée ne pourra pas être détruite.

Quel intérêt ?

Le concept de données immutables est indispensable dans notre monde numérique, mais pas seulement. On retrouve également des dizaines d’exemples de données (ou documents) immutables dans le monde “réel” (comprenez “de tous les jours”).

Dans les deux cas, l’intérêt est le même.

Cela permet d’avoir une source de vérité sur laquelle s’appuyer pour prendre des décisions importantes, à partir de données fiables, figées dans le temps, et dont on peut retracer l’historique.

Quelques exemples

Pour vous prouver que l’on retrouve des données immutables partout, voici une liste (non-exhaustives) très variée :

• Un acte de vente pour un bien immobilier est un document immutable une fois signé
• Une facture est immutable (doit être annulée par un avoir)
• Le montant, le destinataire et l’origine d’un virement bancaire (si erreur, virement dans l’autre sens)
• Le contenu d’une RFC (doit-être modifié par une autre RFC)

C’est également le principe d’immutabilité qui rend le concept de blockchain si puissant.

Parfois, l’immutabilité d’une donnée, ou d’un document, est assurée de manière technique. C’est le cas de la blockchain, qui va assurer l’authenticité et l’immutabilité des transactions grâce à son contrôle du hash de chaque bloc précédent.

Et d’autres fois, c’est une tierce partie qui va assurer l’immutabililité du document (comme le notaire pour l’acte de vente).

Comment modifier une donnée immutable ?

La réponse simple c’est : ça n’est pas possible.

Mais en réalité ce n’est pas grave, parce que l’on ne va pas changer directement notre donnée, mais on va venir y associer des changements.

La frontière parait mince, et pourtant ça fait toute la différence

Prenons un exemple concret : la comptabilité. Ne partez pas, vous allez voir, c’est très simple.

En comptabilité, une facture émise par une entreprise est immutable, elle ne peut ni être annulée, ni supprimée, ni modifiée.

Pourtant, l’erreur est humaine, donc vous pouvez très bien faire une grosse erreur lorsque vous créez votre facture. Imaginons qu’au lieu de facturer 1000€, vous éditez une facture de 10000€

Si une facture n’était pas immutable, on pourrait la détruire, et en recréer une autre.

Sauf que ça ouvrirait la porte à la fraude, aux factures fantômes, et on ne pourrait plus faire confiance à l’historique comptable.

Alors comment faire pour corriger son erreur ? Ca se passe en trois étapes :

• On va garder un historique de notre facture éronée
• On va créer un nouveau document qui s’appelle un “avoir”, c’est comme une facture mais avec un montant négatif, en l’occurence, du même montant que notre précédente facture, ce qui va avoir pour effet d’annuler la somme dûe par le client (qu’on appelle la créance)
• Puis on va recréer une facture avec le bon chiffre, que le client devra payer

Dans cet exemple, chaque document est immutable, on peut corriger ses erreurs, modifier l’état final de notre transaction, mais notre historique de modification sera toujours authentique et vérifiable.

En l’occurence, c’est notre logiciel comptable qui va en partie assurer cette immutabilité en empêchant les modifications et les suppressions de document.

Implémentations techniques

Maintenant que l’on comprend le fonctionnement de l’immutabilité dans son ensemble, voyons quelques concepts techniques basés sur l’immutabilité en informatique/programmation.

Rust

En effet, par défaut en Rust, lorsque vous créez une variable, cette dernière est en réalité immutable. Par exemple avec le code suivant :

let x: i32 = 42;
x = 10;

Error: re-assignment of immutable variable `x`

Car chaque variable déclarée est par défaut immutable

Pour rendre une variable mutable, alors il faudra le déclarer explicitement avec le mot-clé mut, comme ceci :

let mut x: i32 = 42;
x = 10;
println!("{}", x);

Event Sourcing

Il existe également des bases de données qui fonctionnent sur ce principe, c’est ce que l’on appelle de l’event-sourcing (ou approvisionnement d’évènements).

Au lieu de stocker des données dans une table (par exemple des utilisateurs) grâce à des requêtes qui vont aller altérer le contenu de la table, on devra empiler des évènements, sous la forme de commandes :

• Ajout d’une ressource
• Ajout d’une modification de ressource

Par exemple :

• J’ajoute un utilisateur John Doe
• J’ajoute la modification de son age avec la valeur 25
• J’ajoute la modification de son age avec la valeur 35 car je me suis trompé, mais l’état précédent est quand même accessible dans la base de données
• Puis enfin, je ne peux pas supprimer mon utilisateur, mais je peux le marquer comme supprimé, ou désactivé, c’est ce que l’on appelle le “soft-delete”

Git

Enfin pour terminer cette liste d’exemple, quoi d’autre qu’un outil que vous utilisez quotidiennement qui fonctionne sur l’immutabilité de chacun de ses états : Git.

Chaque nouvelle version du code, n’est en réalité qu’une liste de modification entre l’ancienne version, et la nouvelle, avec les ajouts, les suppressions et les modifications.

À noter qu’il est possible de supprimer “de force” certains fichiers de l’historique pour des raisons de sécurité

Car l’objectif de Git n’est pas d’être une source de vérité légale du code, mais simplement de faciliter la gestion des versions.