Dans un article précédent, nous avons examiné Rules as Code, une approche visant à réduire l’écart entre les réglementations et les logiciels. Nous avons illustré qu’il existe de nombreux obstacles pratiques à surmonter, malgré l’objectif louable. L’encodage uniforme des règles avec leur historique, leurs interdépendances et leurs dépendances est un défi qui peut nécessiter un investissement considérable en termes de personnel et de ressources. De plus, une gestion active permanente est nécessaire pour prendre en compte chaque modification apportée aux règles. Même à petite échelle, une collaboration étroite entre juristes et développeurs est indispensable, car des décisions motivées devront régulièrement être prises en matière d’interprétation. En l’absence de normes industrielles et alors que les meilleures pratiques sont encore en cours d’élaboration, les early adopters risquent de devoir payer la pioneer tax. La complexité des compétences gouvernementales ne facilite pas une éventuelle application en Belgique.

Partiellement sous l’impulsion du rapport détaillé de l’OCDE de 2020, certaines administrations se sont déjà pleinement engagées dans l’élaboration de proof-of-concepts, parfois à grande échelle. Il existe donc aujourd’hui plusieurs cadres relativement matures. La France est sans aucun doute le pays pionnier ; l’initiative que nous allons présenter ci-dessous vient de France. Les Pays-Bas ne sont pas en reste : l’administration fiscale néerlandaise utilise depuis un certain temps déjà son propre langage de domaine, RegelSpraak, qu’elle interprète et traite à l’aide du rule engine ALEF. Cependant, le code source publié à ce sujet semble pour l’instant se concentrer davantage sur la méthodologie que sur les applications.

OpenFisca

OpenFisca a vu le jour en 2011 en tant que moteur de microsimulation open source permettant de convertir les règles fiscales et sociales (“tax & benefit system”) en code exécutable. Les effets de cette réglementation, et les éventuelles modifications, peuvent alors être simulés tant pour des cas individuels que pour des populations entières. Parmi les sites web utilisant OpenFisca en arrière-plan, on peut citer LexImpact (simulation des modifications de la législation socio-fiscale), Mes droits sociaux (simulation des droits sociaux) et 1jeune1solution (mesures de soutien diverses). Parmi les exemples étrangers, citons BenefitMe (Nouvelle-Zélande), Les meves ajudes (Barcelone) ou PolicyEngine (Royaume-Uni/États-Unis) – ces derniers ayant toutefois nécessité des modifications importantes du moteur.

Afin de modéliser notre propre système fiscal et/ou de sécurité sociale, nous devons créer une fourche du Template country OpenFisca générique. Plusieurs autres pays ont déjà expérimenté cette approche, comme le Sénégal, le Paraguay et la Tunisie, qui figurent dans la liste des repositories. La législation régionale ou locale peut être ajoutée grâce à des extensions pluginà un système national, comme celui de Paris. Une fois le repository initialisé, nous pouvons commencer à travailler sur ce qui pourrait un jour devenir openfisca-belgium. La modélisation dans OpenFisca se fait en écrivant des classes et des méthodes Python, qui représentent les entités, les variables et les formules de calcul issues de la réglementation.

Malheureusement, c’est à peu près là que s’arrête la partie facile. Le repository du country template est minimaliste et, bien qu’il existe une documentation avec un petit tutoriel pour créer sa propre version, celle-ci se concentre principalement sur les premières étapes. Les directives sur la manière de structurer au mieux notre propre fourche dès que le nombre de variables et de paramètres augmente font largement défaut. Le repository du projet parent openfisca-france peut certes servir d’exemple, mais il est très volumineux et ne permet pas vraiment de comprendre les raisons de leurs choix structurels ou architecturaux.

L’aspect d’une GUI ou d’une interface web reste également sous-estimé. Pourtant, l’interface de LexImpact simulator pour l’impôt sur le revenu en France, par exemple, est justement un point fort. Comme guide pour la construction d’une interface web, on se réfère à tutoriels et slides d’un workshop, où les premières étapes sont présentées dans Svelte, React et VueJS. Cependant, le fait qu’une GUI ou une application web doive encore être construite from scratch en plus d’une instance OpenFisca propre constitue un obstacle supplémentaire à l’adoption. La construction d’une GUI est en effet chronophage. Il serait utile de disposer de bibliothèques OpenFisca-GUI avec des composants réutilisables pour les principaux frameworks web, afin qu’un serveur OpenFisca puisse éventuellement être associé à une interface web générique par défaut. Un plugin Drupal semble actuellement être le seul à aller quelque peu dans cette direction.

L’IA à la rescousse ?

Étant donné qu’OpenFisca, Svelte, React et Vue sont tous nouveaux pour l’auteur, et que les outils d’IA promettent d’accélérer l’intégration des développeurs, nous saisissons l’occasion pour tester simultanément l’IDE Cursor alimenté par l’IA. Ce clone de Visual Studio Code est enrichi de la possibilité d’appeler des LLM (dans notre cas, basés sur le cloud public). De plus, des sélections issues de fichiers du projet peuvent être marquées comme contexte pour la question. Cursor peut fournir des suggestions d’ajouts ou de modifications à apporter aux fichiers qui, une fois approuvées, peuvent être directement intégrées dans la base de code.

Interagir avec des modèles d’IA comporte des risques pour la confidentialité. Cette expérience est principalement possible car nous travaillons avec du code open source, des réglementations publiées et leur documentation également publique, qui ne sont pas sensibles. Cependant, étant donné que tout ce qui se trouve dans l’IDE peut être envoyé au modèle de langage, nous devons toujours veiller à ne pas ouvrir dans l’IDE des fichiers contenant des identifiants, des clés API ou des informations personnelles. Cela reste la responsabilité de chaque développeur. Dans tous les cas, il est recommandé d’être prêt à faire tourner les clés API ou les credentials, car dans le feu de l’action d’un debugging, il est facile de partager trop d’informations avec un LLM.

Enfin, il convient de mentionner que cette expérience a été réalisée avec les versions 1.6 et 1.7 de Cursor en septembre-octobre 2025, avec le modèle de langage sous-jacent GPT-4.5 d’OpenAI, puis GPT-5.0, utilisé avec une clé API dédiée (et non via Cursor). Les versions ultérieures disposent de nombreuses fonctionnalités plus récentes (notamment des workflows agentic) et il est possible que l’expérience soit aujourd’hui (janvier 2026) très différente. Cependant, les principaux enseignements restent généralement valables pour tout développement alimenté par l’IA, que ce soit via IDE, ligne de commande ou les deux (par exemple, Anthropic Claude Code).

Dans un premier temps, nous ajoutons la documentation nécessaire à notre projet. Nous prenons comme exemple la loi du 26 mai 2002 concernant le droit à l’intégration sociale. Avec tous les autres arrêtés royaux, lois et circulaires pertinents, elle est clairement répertoriée sur le site web du SPP Intégration sociale. Afin de faciliter la recherche et l’interprétation du texte pour un LLM dans un IDE, nous l’enregistrons sous forme de fichier texte plat sans mise en forme, que nous ajoutons à un nouveau dossier contenant les sources pertinentes dans l’arborescence source du projet. Nous ne pouvons que supposer que cette approche est optimale, mais il faut bien commencer quelque part.

Entités

Les entités dans OpenFisca indiquent pour qui nous effectuons le calcul. Il peut s’agir d’individus, de familles ou d’autres groupes de personnes (entreprises, organisations, etc.). Ce sont les fondements sur lesquels nous pourrons ensuite spécifier des variables qui, ensemble, formeront une “situation” pour laquelle nous pourrons effectuer un calcul. Les entités Person et Household sont déjà présentes dans le code. Une question logique se pose donc : sur la base du texte de loi donné, pouvons-nous définir d’autres entités qui seraient utiles ?

Après avoir posé la question à GPT-5 dans Cursor, avec le texte de loi sélectionné comme contexte, il nous est proposé d’ajouter les entités suivantes :

• Eligible Person for Societal Integration
• Living Wage Recipient
• Employment Project Participant

Les modifications proposées au code sont syntaxiquement correctes. Cependant, aucune de ces trois modifications n’est utile ou nécessaire : dans les trois cas, il s’agit de variantes de Person. Les propriétés qui leur permettraient, par exemple, de percevoir un revenu d’intégration sont plutôt des variables ajoutées à l’entité Person déjà existante. La valeur de ces variables dépend en outre d’autres variables également liées à ce même individu, telles que les revenus du travail ou le statut d’invalidité. Les entités, qui servent principalement à des concepts autonomes, ne sont pas le bon choix dans ce cas. 

En outre, GPT-5 semble avoir mal interprété le concept de “rôle” au sein d’une entité de groupe OpenFisca. Il tente de construire “Eligible Person for Societal Integration” avec différents “rôles” comme composants : “Belgian National”, “EU Citizen”, “Foreigner”, “Stateless”, “Refugee”… Sans doute parce que ces possibilités apparaissent à l’Art.3, 3°, de la loi. Dans OpenFisca, cependant, une entité de groupe est composée de personnes qui se voient chacune attribuer un rôle. Un Household comprend ainsi des rôles Adult et Child. Il est assez absurde qu’une EligiblePerson puisse comprendre plusieurs Foreigners. La nationalité ou l’origine, ou d’autres conditions fixées dans cette loi, sont également ici des variables liées à la personne, et non à une entité en soi. 

À un autre moment, une entité distincte a été créée pour le CPAS. Bien qu’il semble logique de modéliser les CPAS et de les considérer comme une entité – ils sont en effet mentionnés dans la loi –, ce n’est pas (encore) le cas ici. Il n’existe en effet pas différents types de CPAS avec des caractéristiques ou des rôles différents, pour lesquels nous devrions effectuer des calculs différents à chaque fois. Dans le contexte de cette loi, où c’est le citoyen pour lequel nous calculons le droit à l’aide sociale, le CPAS est avant tout une donnée constante et invariable. Dans OpenFisca, nous pouvons donc pour l’instant ignorer cet aspect. (Un type d’entité “institut” n’est pas non plus prévu.) 

Nous constatons ici que Cursor ne peut pas répondre “non” à la question de savoir si d’autres entités utiles peuvent être ajoutées. Il ne peut pas critiquer ou corriger de son propre chef le raisonnement qui sous-tend cette question. Tout au long de l’expérience, Cursor et GPT-5 ont également montré une tendance à la complexité inutile. Cela représente un risque important pour les développeurs qui travaillent avec du code ou des frameworks inconnus : si l’on suit trop rapidement ces suggestions, on risque de perdre le contrôle par la suite et de devoir apporter des corrections très difficiles aux fondements du projet. Une fois qu’une mauvaise voie a été empruntée, il s’avère également difficile de revenir en arrière et de faire oublier ces étapes. Surtout si on les a d’abord acceptées par ignorance, elles s’inscrivent dans le contexte et sont reprises dans les questions suivantes. Ce “context rot” insidieux est désormais un problème bien connu et une cause importante de perte de temps avec le AI enabled coding.

Variables

Le cœur du modèle réside dans les variables qui représentent les droits et les conditions prévus par la loi. L’article 2 de la loi énumère les différentes formes d’intégration sociale auxquelles une personne peut avoir droit (notamment l’emploi, le revenu d’intégration, le projet individualisé). L’article 3 contient les conditions qu’une personne doit remplir pour exercer ce droit. Nous avons transposé ces dispositions étape par étape dans le code.

Dans la pratique, le droit à l’intégration sociale signifie qu’un CPAS doit soutenir une personne par le biais (1) d’un emploi ou d’une formation, (2) d’un revenu d’intégration, ou (3) d’un projet individualisé d’intégration sociale. Cela peut se traduire par trois variables booléennes sur l’entité Personne, par exemple employment_right, living_wage_right et individualized_project_right. Cursor fournit ici une suggestion de code pertinente et propose une formule placeholder simple : tant qu’une personne “est éligible à l’intégration” (une autre variable), le droit s’applique. Nous obtenons ainsi la définition suivante de employment_right :

class employment_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  def formula(person, period, parameters):
    return person("eligible_for_integration", period)

class employment_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  def formula(person, period, parameters):
    return person("eligible_for_integration", period)

Le contenu de cette formule placeholder est abordé dans l’article 3 ci-dessous. Celui-ci modélise les conditions suivantes pour être éligible :

• Séjour en Belgique (selon les règles à déterminer par arrêté royal).
• Âge : la personne est majeure (18 ans et plus) ou, si elle est mineure, assimilée à une personne majeure selon les exceptions prévues par la présente loi.
• Nationalité ou statut de séjour : la personne est belge, citoyenne de l’UE (après 3 mois de séjour), étrangère enregistrée, apatride, réfugiée ou bénéficiaire d’une protection subsidiaire.
• Ressources insuffisantes
• Disposition à travailler (sauf si cela est impossible pour des raisons de santé ou d’équité).
• Épuisement des droits issus d’autres régimes

Toutes ces conditions sont regroupées dans une variable booléenne centrale societal_integration_right. Cette variable indique si une personne, compte tenu de sa situation personnelle, peut prétendre à l’intégration sociale. En fait, il s’agit de la traduction de “la personne remplit-elle toutes les conditions de l’article 3 ?“. La formule combine toutes les sous-conditions :

class societal_integration_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  label = "Right to societal integration"
  def formula(person, period, parameters):
    residency = person("residency_status", period)
    is_major = person("is_major", period)
    nationality = person("nationality_status", period) in ["belgian", "eu_citizen", "registered_foreigner", "stateless", "refugee"]
    insufficient_income = not person("has_sufficient_income", period)
    willing_to_work = person("willing_to_work", period)
    claiming_benefits = person("claiming_benefits", period)
    return (residency and is_major and nationality and insufficient_income and willing_to_work and claiming_benefits)

class societal_integration_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  label = "Right to societal integration"
  def formula(person, period, parameters):
    residency = person("residency_status", period)
    is_major = person("is_major", period)
    nationality = person("nationality_status", period) in ["belgian", "eu_citizen", "registered_foreigner", "stateless", "refugee"]
    insufficient_income = not person("has_sufficient_income", period)
    willing_to_work = person("willing_to_work", period)
    claiming_benefits = person("claiming_benefits", period)
    return (residency and is_major and nationality and insufficient_income and willing_to_work and claiming_benefits)

Notons ici quelques lacunes étranges dans la suggestion de Cursor. Ainsi, le nom de la variable societal_integration_right n’est pas identique au placeholder eligible_for_integration défini précédemment, alors que c’était pourtant l’intention. En outre, la condition de nationalité omet tout simplement la possibilité d’une protection subsidiaire. Enfin, la sixième condition, qui stipule que la personne doit d’abord faire valoir ses droits à d’éventuelles prestations sociales, est mentionnée de manière très rudimentaire sous le nom de claiming_benefits, un nom de variable qui ne reflète pas vraiment ce qui est visé.

Nous pouvons donc accepter cette suggestion, mais nous sommes immédiatement obligés d’apporter trois corrections. Nous pouvons facilement détecter la non-conformité du nom de la variable, car les tests ne fonctionneront pas s’il reste des variables non déclarées dans le code. Un élément manquant dans la formule, tel qu’une condition oubliée, est cependant beaucoup plus facile à négliger et, s’il n’est pas détecté, entraîne à coup sûr des erreurs d’exécution. Nous constatons donc ici la nécessité de se référer au texte de loi afin de vérifier que le code généré correspond bien à ce que dit le texte de loi. Cette vérification doit être effectuée avec suffisamment d’attention pour pouvoir identifier les appellations malheureuses ou les interprétations subtiles erronées du texte.

Les corrections éventuelles doivent également être effectuées le plus rapidement possible. Si un code erroné reste présent dans l’éditeur, il fera en effet partie du contexte utilisé par le modèle d’IA et servira lui-même de base pour les suggestions suivantes. Cela peut conduire à une situation où l’on continue à recevoir des suggestions contenant toujours les mêmes erreurs, qu’il faut donc corriger à chaque fois, ce qui n’est pas propice à la productivité.

Les variables utilisées dans la méthode formula() de societal_integration_right ci-dessus doivent bien sûr être définies à leur tour : pour chacune de ces variables, nous devons écrire une classe. Cela peut donner lieu à des chaînes complexes de dépendances. Ainsi, is_major pourrait être une simple variable d’entrée booléenne, mais nous pouvons également la calculer sur la base de la date du jour et d’une nouvelle variable birthdate. Le calcul de la formule des variables peut également utiliser les paramètres d’une loi – ainsi, en Belgique, la majorité n’est atteinte qu’à partir de 18 ans depuis le 1^er mai 1990. Cela nous ramènerait alors au Code civil et à son histoire – pour rester concis, nous n’approfondirons pas cette question pour l’instant.

Dernière remarque : le modèle tel qu’il est construit ici est bien sûr une représentation simplifiée. Notez toutefois que même dans ce cas, après seulement trois articles de loi, nous avons déjà défini une dizaine de classes Python, avec la possibilité d’en ajouter d’autres si nous souhaitons approfondir le sujet. Cursor et GPT-5 écrivent un code relativement verbeux, avec de nombreuses variables et méthodes auxiliaires, qui pourraient parfois être simplifiées. Certains détails de la loi, tels que le délai d’attente de trois mois pour les citoyens de l’UE ou les exceptions qui existent pour certaines catégories de mineurs (art. 7), nécessiteraient de nombreuses variables ou conditions supplémentaires dans un modèle complet.

IA et code : quelques pièges

En ce qui concerne les meilleures pratiques pour l’utilisation de l’IA dans le cadre de tels projets, nous identifions encore quelques pièges, en plus de ceux que nous avons déjà mentionnés.

Ajouter trop de documentation au début conduit rapidement à une “confusion contextuelle“, dans laquelle les suggestions ou les réponses du LLM sont basées sur des informations qui ne sont pas (encore) pertinentes. Il est préférable d’ajouter la documentation progressivement, au fur et à mesure que la fonctionnalité se développe, plutôt que d’ajouter l’analyse complète et le contexte à l’IDE dès le départ. Dans le cas de la réglementation, ajoutez les règles article par article à l’IDE, au fur et à mesure de l’avancement du projet, et résistez à la tentation d’intégrer à l’avance l’ensemble du texte de loi dans l’IDE en tant que “référence encyclopédique”.

Le “context rot” ou “context poisoning” survient lorsque l’IA s’engage dans une mauvaise voie, s’y enlise et finit par oublier des informations plus pertinentes, ce qui rend la récupération plus difficile. Le “context quarantining“, qui consiste à diviser le problème en sous-problèmes plus petits, chacun avec son propre contexte, est un remède logique à ce problème. C’est également la voie empruntée par la plupart des systèmes de “deep research” ou “multi agentic“. Dans un IDE, cela impliquerait qu’un système d’IA devrait segmenter la base de code et la documentation à partir d’une certaine taille. La mise en œuvre technique de cette solution en arrière-plan semble être un défi de taille, et différents IDE développeront probablement leur propre approche à cet égard dans un avenir proche.

Une autre source de frustration était que l’IA plaçait parfois le code ou les fichiers au mauvais endroit ou supposait que certaines choses existaient. Par exemple, les formules générées faisaient référence à des variables qui n’étaient pas encore définies. Cela génère bien sûr des messages d’erreur lors des tests. Nous devions alors ajuster l’IA ou insérer nous-mêmes des variables supplémentaires pour couvrir ces références. Même des détails mineurs, tels que le formatage de la documentation ou la création ou non des importations nécessaires, nécessitaient parfois une correction manuelle. Ce type d’incohérences démontre qu’il n’est pas possible de se fier aveuglément aux suggestions de l’IA. Un développeur doit constamment vérifier si le code généré correspond à l’intention et, dans le cas contraire, intervenir immédiatement.

publi.codes

Nous souhaitons également signaler l’existence de publi.codes comme alternative possible à OpenFisca. Plus récent et plus moderne, ce dernier exige que les règles soient codées au format YAML, ce qui est beaucoup plus pratique que l’écriture de sous-classes en Python et beaucoup plus lisible pour les non-développeurs. En contrepartie, on est toutefois limité aux opérations autorisées par le moteur sous-jacent. Ce n’est qu’à partir de la version 2, encore en cours de développement, que des possibilités d’encoder des barèmes ou des abattements (montants exonérés), très fréquents en Belgique, seront ajoutées.

La version actuelle de publi.codes dépend en outre de l’écosystème NPM, qui est actuellement régulièrement affecté par des attaques du supply chain. Publi.codes v2 serait quant à lui compilé vers OCaml, un langage de programmation que nous n’utilisons pas chez Smals. Étant donné qu’il y a peu de chances que Smals souhaite introduire ce langage de programmation dans son portefeuille (et mettre en place une équipe de support à cet effet), il ne semblait pas très utile d’examiner publi.codes en profondeur dans le cadre de cet exercice. Il convient toutefois de noter que publi.codes dispose de quelques libraries prêtes à l’emploi en matière de composants UI.

Conclusion

OpenFisca et publi.codes sont deux systèmes particulièrement performants lorsque les règles peuvent être modélisées sous forme de calculs explicites et testables. Ils sont moins adaptés aux réglementations qui font appel aux décisions discrétionnaires, à la libre interprétation, aux exceptions sans paramètres clairs ou aux workflows de “case management”. Il s’agit avant tout de systèmes de calcul et de règles, et non de plateformes de traitement de dossiers. Ils peuvent donc éventuellement servir de moteur pour des applications capables de calculer les impôts ou les allocations au niveau de la personne/du ménage (droit à quelque chose + montant), ou pour simuler l’impact politique d’éventuelles modifications (“combien coûte cette réforme ?”, “qui y gagne/y perd ?”). Cela peut être intéressant tant pour les législateurs que pour les citoyens.

Cependant, un projet OpenFisca ne se met pas en place rapidement. Sur le plan conceptuel, OpenFisca est quelque peu déroutant pour un développeur : bien qu’OpenFisca utilise des classes Python, celles-ci ne servent pas à modéliser des objets, mais à enregistrer de manière déclarative des entités, des variables et des règles de calcul issues de la réglementation. Étant donné que par variable, il faut écrire une classe et que des dizaines de variables peuvent facilement entrer en jeu dans un article de loi complexe, on se retrouve avec une pile de code qui s’accumule rapidement et qui est difficile à organiser de manière claire. En outre, le développement d’une interface graphique nécessite également beaucoup de travail supplémentaire. Le projet manque encore de tooling nécessaire pour atténuer ces problèmes récurrents. (Bien sûr, cela n’aide pas lorsque l’administration publique, qui semble considérer que les projets open source peuvent par définition s’autofinancer, décide soudainement de fermer les vannes en 2020.

Enfin, nous pouvons ajouter que cette expérience a été à la fois un reality check utile et instructif sur ce que les LLM peuvent apporter, et gâcher, à un environnement de travail de développeur. Le meilleur conseil reste de garder les rênes fermement en main et de travailler par petites étapes incrémentielles. Certains outils d’IA seront plus performants que d’autres dans divers domaines. Donner des réponses négatives ou détecter des erreurs dans les questions reste un défi pour les LLM, ce qui comporte certains risques. Cependant, l’assistance IA dans les IDE évolue rapidement, et une expérience similaire se déroulera sans doute différemment l’année prochaine.

Rules As Code ne signifie certainement pas qu’aujourd’hui, nous pouvons fournir un texte de loi à une IA pour qu’elle déploie un programme. Cependant, dans les années à venir, les forums spécialisés accorderont sans aucun doute une grande attention à l’interaction entre la loi, la mise en œuvre et les outils d’IA. Pour l’instant, la complexité de la réglementation elle-même, même avec une IA de plus en plus performante, reste le principal obstacle aux projets Rules As Code.

In een vorig artikel fileerden we Rules as Code, een aanpak die erop gericht is om de kloof tussen regelgeving en software te verkleinen. We illustreerden daarbij dat er heel wat praktische obstakels te overkomen zijn, niettegenstaande het lovenswaardige doel. De uniforme encodering van regels met hun geschiedenis, verwevenheden en afhankelijkheden is een uitdaging die een aanzienlijke investering van mensen en middelen kan vergen. Permanent actief beheer is daarenboven nodig om elke wijziging aan de regels op te vangen. Zelfs op kleine schaal is een nauwe samenwerking tussen juristen en ontwikkelaars onontbeerlijk, want regelmatig zullen gemotiveerde beslissingen genomen moeten worden over interpretatie. Omdat industriestandaarden nog ontbreken en best practices nog volop in ontwikkeling zijn, riskeer je als early adopter de zogenaamde pioneer tax te moeten betalen. De complexe lasagna van overheidsbevoegdheden maakt een eventuele toepassing in België niet eenvoudiger.

Mede onder impuls van het uitgebreide rapport van de OESO uit 2020, hebben enkele overheden toch al volop ingezet op het uitwerken van, soms vrij grootschalige, proof-of-concepts. Er bestaan vandaag dan ook enkele frameworks die relatief matuur zijn. Ongetwijfeld is Frankrijk het voortrekkersland; het initiatief dat we hieronder zullen toelichten komt van Franse bodem. Ook in Nederland beweegt er wel wat: de Nederlandse fiscus gebruikt al enige tijd haar eigen domeintaal RegelSpraak die zij met de rule engine ALEF interpreteert en verwerkt, echter lijkt de daarover gepubliceerde broncode vooralsnog meer op methodologie dan op applicaties te focussen.

OpenFisca

OpenFisca is ontstaan in 2011 als open-source microsimulatie-motor om belasting- en uitkeringsregels (“tax & benefit system”) om te zetten naar uitvoerbare code. De effecten van die regelgeving, en eventuele wijzigingen, kunnen dan gesimuleerd worden voor zowel individuele cases als hele populaties. Websites met OpenFisca in de achtergrond zijn onder andere LexImpact (simulatie van wijzigingen in socio-fiscale wetgeving), Mes droits sociaux (simulatie van sociale rechten), en 1jeune1solution (allerhande steunmaatregelen). Buitenlandse voorbeelden zijn BenefitMe (Nieuw-Zeeland), Les meves ajudes (Barcelona), of PolicyEngine (UK/USA) – deze laatsten wel met grondige aanpassingen aan de engine.

Om ons eigen belasting- en/of sociale-zekerheidsstelsel te modelleren, moeten we een fork maken van het generieke OpenFisca country-template. Verschillende andere landen hebben er tenminste al mee geëxperimenteerd, zo vinden we in de lijst van repositories o.a. Senegal, Paraguay en Tunesië. Regionale of lokale wetgeving kan middels plugin-extensies toegevoegd worden aan een nationaal systeem, zoals deze voor Parijs. Eens de repository geïnitialiseerd, kunnen we beginnen werken aan wat misschien ooit openfisca-belgium kan worden. De modellering in OpenFisca gebeurt door het schrijven van Python-klassen en -methodes, die de entiteiten, variabelen en berekeningsformules uit de regelgeving vertegenwoordigen.

Helaas houdt het gemakkelijke deel daar ongeveer op. De country-template repository is minimalistisch en hoewel er wel documentatie, met een kleine tutorial, beschikbaar is om een eigen versie uit te bouwen, focust deze vooral op de eerste stappen. Richtlijnen over hoe we onze eigen fork best zouden structureren zodra het aantal variabelen en parameters groeit, ontbreken grotendeels. De repository van moederproject openfisca-france kan weliswaar als voorbeeld dienen, maar is dan weer erg groot, en het waarom van hun structurele of architecturale keuzes is er niet echt uit af te leiden.

Ook het aspect van een GUI of webinterface blijft onderbelicht. Nochtans is de interface van bijvoorbeeld de LexImpact simulator van de Franse inkomstenbelasting, net een sterk punt. Als leidraad voor bouwen van een webinterface verwijst men naar tutorials en slides van een workshop, waar men de eerste stappen toont in Svelte, React en VueJS. Het is echter een extra barrière voor adoptie, dat een GUI of webapp nog from scratch zelf te bouwen is bovenop een eigen OpenFisca-instantie. Het bouwen van een GUI is immers tijdrovend. Het zou nuttig zijn om OpenFisca-GUI-libraries te hebben met herbruikbare componenten voor de belangrijkste web frameworks, zodat een OpenFisca server misschien met een generieke default webinterface gebundeld kan worden. Een Drupal-plugin lijkt momenteel het enige project dat enigszins in die richting gaat.

AI to the rescue?

Gezien OpenFisca, Svelte, React en Vue allen nieuw zijn voor de auteur, en AI-tooling belooft om developers sneller te laten onboarden, grijpen we de kans om de AI-powered IDE Cursor tegelijk uit te testen. Deze kloon van Visual Studio Code is verrijkt met de mogelijkheid tot het aanroepen van (in ons geval public-cloud-gebaseerde) LLMs. Daarbij kunnen selecties uit bestanden in het project worden gemarkeerd als context bij de vraag. Cursor kan suggesties geven voor toevoegingen of wijzigingen aan bestanden die, eens goedgekeurd, direct geïntegreerd kunnen worden in de codebase.

Interageren met AI-modellen houdt privacy-risico’s in. Dit experiment vooral mogelijk omdat we werken met open-source code, gepubliceerde regelgeving, en de eveneens openbare documentatie daarvan, wat niet gevoelig is. Maar gezien alles wat zich in de IDE bevindt naar het taalmodel gestuurd kan worden, moeten we er nog steeds op letten dat we geen bestanden openen in de IDE die credentials, API keys of persoonlijke informatie bevatten. Dat blijft de verantwoordelijkheid van de individuele developer. Sowieso is het goede praktijk om voorbereid te zijn op het roteren van API keys of credentials, want in het heetst van een debugging-strijd is oversharing met een LLM snel gebeurd.

Tot slot moeten we vermelden dat dit experiment nog werd uitgevoerd met Cursor versies 1.6 en 1.7 in september-oktober 2025, met OpenAI’s GPT-4.5 en later GPT-5.0 als achterliggend taalmodel, gebruikt met een eigen API key (niet via Cursor). Latere versies hebben heel wat nieuwere features (waaronder meer agentic workflows) en het zou kunnen dat de ervaring vandaag (januari 2026) al heel anders zou zijn. De belangrijkste lessen blijven echter algemeen gelden voor alle AI-powered development, of dat nu via IDE, command line of beide gebeurt (vb. Anthropic Claude Code).

Als eerste stap voegen we de nodige documentatie toe aan ons project. Als case nemen we de Wet op de Maatschappelijke Integratie van 26 mei 2002. Samen met alle andere relevante wetten, koninklijke besluiten en omzendbrieven is die overzichtelijk geïnventariseerd op de website van de POD Maatschappelijke Integratie. Om de tekst gemakkelijk doorzoekbaar en interpreteerbaar te maken voor een LLM in een IDE, slaan we hem op als plat tekstbestand zonder opmaak, en dat voegen we toe aan een nieuw mapje voor relevant bronmateriaal in de source tree van het project. Of dat optimaal is, daar hebben we het raden naar, maar we moeten ergens beginnen.

Entiteiten

Entiteiten in OpenFisca drukken uit voor wie we de berekening maken. Dat kunnen individuen, gezinnen of andere groeperingen van mensen zijn (bedrijven, organisaties, …). Het zijn de basisbouwstenen waarvoor we later variabelen zullen kunnen specifiëren die samen een “situatie” vormen waarvoor we een berekening zullen kunnen doen. Person en Household zijn al aanwezig in de code. Een logische vraag is dus of we, op basis van de gegeven wettekst, andere entiteiten kunnen definiëren die nuttig zouden zijn.

Na het stellen van de vraag aan GPT-5 in Cursor, met de wettekst geselecteerd als context, wordt voorgesteld de volgende entiteiten toe te voegen:

• Eligible Person for Societal Integration
• Living Wage Recipient
• Employment Project Participant

De voorgestelde aanpassingen aan de code zijn syntactisch correct. Geen van deze 3 zijn echter nuttig of noodzakelijk: het gaat in alledrie de gevallen om varianten van Person. De eigenschappen die maken dat ze bijvoorbeeld een leefloon zouden ontvangen, zijn veeleer variabelen toegevoegd aan de reeds bestaande Person entiteit. De waarde van die variabelen hangt bovendien af van andere variabelen die eveneens aan datzelfde individu gebonden zijn, zoals een inkomen uit werk of een handicapstatus. Entiteiten, die vooral dienen voor op zichzelf staande concepten, zijn hiervoor niet de juiste keuze.

Daarnaast lijkt GPT-5 het concept van een “rol” binnen een OpenFisca groepsentiteit verkeerd te hebben begrepen. Hij probeert “Eligible Person for Societal Integration” op te bouwen met verschillende “rollen” als onderdelen: “Belgian National”, “EU Citizen”, “Foreigner”, “Stateless”, “Refugee”… Dit ongetwijfeld omdat deze mogelijkheden verschijnen in Art.3, 3° lid, van de wet. In OpenFisca is een groepsentiteit echter samengesteld uit Personen die elk een rol krijgen. Een Household bevat zo Adult en Child rollen. Het is vrij nonsensicaal dat een EligiblePerson meerdere Foreigners zou kunnen bevatten. Nationaliteit of herkomst, of andere voorwaarden die gesteld worden in deze wet, zijn ook hier variabelen die gebonden zijn aan de persoon, geen entiteit op zich.

Op een ander moment werd nog een aparte entiteit gecreëerd voor het OCMW. Hoewel het logisch lijkt om de OCMWs te modelleren en als een entiteit te beschouwen – ze worden immers vermeld in de wet – is het dat hier (nog) niet. Er zijn immers geen verschillende types OCMWs met verschillende eigenschappen of rollen, waarvoor we telkens andere berekeningen moeten maken. In de context van deze wet, waarbij het de burger is voor wie we het recht op maatschappelijke steun berekenen, is het OCMW vooral een constant, invariant gegeven. In OpenFisca kunnen we dat dus vooralsnog overslaan. (Een entiteitstype “instituut” is ook niet voorzien.)

We merken hier dus dat Cursor niet “nee” kan antwoorden op de vraag of er nuttige andere entiteiten kunnen toegevoegd worden. Het kan de denkrichting achter die vraag niet bekritiseren of corrigeren uit eigen beweging. Doorheen het hele experiment bleken Cursor en GPT-5 ook een neiging te vertonen tot onnodige complexiteit. Dit is voor developers die met onbekende code of frameworks werken een groot risico: indien men te snel te ver meegaat met zulke suggesties, dreigt men later de pedalen te verliezen en achteraf erg moeilijke correcties te moeten aanbrengen aan de fundamenten van het project. Eens een verkeerde route is ingeslagen, blijkt het ook moeilijk om op de stappen terug te keren en deze weer te doen vergeten. Zeker als men ze eerst onwetend heeft toegelaten, komen ze terecht in de context en wordt er in vervolgvragen op verdergebouwd. Deze sluipende “context rot” is ondertussen een bekend probleem en een belangrijke oorzaak van tijdverlies met AI-enabled coding.

Variabelen

De kern van het model zit in de variabelen die de rechten en voorwaarden uit de wet voorstellen. Artikel 2 van de wet somt de verschillende vormen van maatschappelijke integratie op waarop iemand recht kan hebben (o.a. tewerkstelling, leefloon, geïndividualiseerd project). Artikel 3 bevat de voorwaarden waaraan een persoon moet voldoen om van dat recht gebruik te maken. We hebben deze bepalingen stap voor stap in code omgezet.

Recht op maatschappelijke integratie betekent in de praktijk dat een OCMW een persoon moet ondersteunen via (1) een job of opleiding, (2) een leefloon, of (3) een geïndividualiseerd project voor maatschappelijke integratie. Dit kan vertaald worden naar drie boolean variabelen op de Persoon-entiteit, bijvoorbeeld employment_right, living_wage_right en individualized_project_right. Cursor geeft hier een goede code-suggestie, en voorziet een eenvoudige placeholder-formule: zolang iemand “in aanmerking komt voor integratie” (een andere variabele) zou het recht gelden. We bekomen een definitie van employment_right als volgt:

class employment_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  def formula(person, period, parameters):
    return person("eligible_for_integration", period)

class employment_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  def formula(person, period, parameters):
    return person("eligible_for_integration", period)

De invulling van deze placeholder-formule komt aan bod in het daaropvolgende Artikel 3. Die modelleert de volgende voorwaarden om in aanmerking te komen:

• Verblijf in België (volgens de regels nader te bepalen bij KB).
• Leeftijd: De persoon is meerderjarig (18+), of als minderjarige gelijkgesteld aan een meerderjarige volgens de uitzonderingen in deze wet.
• Nationaliteit of verblijfsstatuut: De persoon is Belg, EU-burger (na 3 maanden verblijf), ingeschreven vreemdeling, staatloze, vluchteling of subsidiair beschermde.
• Onvoldoende bestaansmiddelen
• Werkbereidheid (tenzij onmogelijk om gezondheidsredenen of billijkheidsredenen).
• Rechten uit andere stelsels uitgeput

Al deze voorwaarden komen samen in één centrale boolean variabele societal_integration_right. Die variabele geeft aan of iemand, gegeven zijn persoonlijke situatie, recht kan hebben op maatschappelijke integratie. In feite is dit de vertaalslag van “voldoet de persoon aan alle voorwaarden van art.3?”. De formule combineert alle subvoorwaarden:

class societal_integration_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  label = "Right to societal integration"
  def formula(person, period, parameters):
    residency = person("residency_status", period)
    is_major = person("is_major", period)
    nationality = person("nationality_status", period) in ["belgian", "eu_citizen", "registered_foreigner", "stateless", "refugee"]
    insufficient_income = not person("has_sufficient_income", period)
    willing_to_work = person("willing_to_work", period)
    claiming_benefits = person("claiming_benefits", period)
    return (residency and is_major and nationality and insufficient_income and willing_to_work and claiming_benefits)

class societal_integration_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  label = "Right to societal integration"
  def formula(person, period, parameters):
    residency = person("residency_status", period)
    is_major = person("is_major", period)
    nationality = person("nationality_status", period) in ["belgian", "eu_citizen", "registered_foreigner", "stateless", "refugee"]
    insufficient_income = not person("has_sufficient_income", period)
    willing_to_work = person("willing_to_work", period)
    claiming_benefits = person("claiming_benefits", period)
    return (residency and is_major and nationality and insufficient_income and willing_to_work and claiming_benefits)

Let hier vooral op enkele vreemde lacunes in de suggestie van Cursor. Zo is de naam van de variabele societal_integration_right niet gelijk aan de eerder gedefinieerde placeholder eligible_for_integration, hoewel dat wel de bedoeling is. Daarnaast wordt in de nationaliteitsvoorwaarde de mogelijkheid van subsidiair beschermden simpelweg vergeten! Tot slot is de zesde voorwaarde, dat men eerst zijn rechten laat gelden op eventuele sociale uitkeringen, wel erg rudimentair benoemd als claiming_benefits – een variabelenaam die niet echt dekt wat bedoeld wordt.

We kunnen deze suggestie dus wel aanvaarden, maar we zijn al direct verplicht om 3 correcties door te voeren. De niet-overeenkomst van de variabelenaam kunnen we daarbij nog gemakkelijk detecteren omdat de tests niet zullen werken als er nog ongedeclareerde variabelen in de code zitten. Een mankerend element in de formule, zoals een vergeten voorwaarde, is echter veel gemakkelijker over het hoofd gezien, en leidt wanneer dat ongedetecteerd blijft gegarandeerd tot fouten in de uitvoering. Hier merken we dus echt wel de noodzaak om terug te koppelen naar de wettekst om te verifiëren dat de gegenereerde code wel degelijk overeenkomt met wat de wettekst zegt. Deze terugkoppeling moet aandachtig genoeg gebeuren om ook ongelukkige benamingen of subtiele misinterpretaties van te tekst te kunnen identificeren.

Eventuele correcties kunnen daarnaast ook best zo snel mogelijk gebeuren. Als foutieve code in de editor aanwezig blijft, gaat ze immers deel uitmaken van de context die het AI-model gebruikt en dient ze zelf als fundament voor daaropvolgende suggesties. Dit kan leiden tot een situatie waarbij men suggesties blijft ontvangen waarin steeds dezelfde fouten terugkomen, die men dus ook telkens weer moet corrigeren, wat niet bevorderlijk is voor de productiviteit.

De variabelen gebruikt in de formula() methode van societal_integration_right hierboven, moeten uiteraard op hun beurt ook gedefinieerd worden: voor elk van deze variabelen moeten we een klasse schrijven. Dit kan aanleiding geven tot complexe kettingen van afhankelijkheden. Zo zou is_major een eenvoudige booleaanse inputvariabele kunnen zijn, maar we kunnen dat ook berekenen op basis van de datum van vandaag en weer een nieuwe variabele birthdate. De berekening van de formule van de variabelen kan daarnaast ook gebruik maken van de parameters van een wet – zo is de meerderjarigheid in België pas vanaf 18 jaar sinds 1 mei 1990. Dat zou ons dan weer bij het Burgerlijk Wetboek brengen, en haar geschiedenis – om het beknopt te houden gaan we daar nu niet verder op in.

Laatste opmerking: het model zoals hier gebouwd is uiteraard een vereenvoudigde weerspiegeling. Merk wel op dat we zelfs dan, slechts 3 artikels ver in een wet, al snel 10 Python-klassen hebben gedefinieerd hebben, met potentieel voor meer als we echt in de diepte zouden willen gaan. Cursor en GPT-5 schrijven daarbij relatief verbose code, met vele hulpvariabelen en -methodes, die soms echt wel eenvoudiger kan. Sommige details uit de wet, zoals de 3-maanden wachttijd voor EU-burgers, of de uitzonderingen die bestaan voor bepaalde categorieën van minderjarigen (Art. 7), zouden in een volwaardig model nog heel wat extra variabelen of condities vergen.

AI en code: enkele valkuilen

Wat betreft best practices voor de inzet van AI-hulp bij zulke projecten, identificeren we nog enkele valkuilen, naast diegene die we tot nu toe al genoemd hebben.

Teveel documentatie toevoegen in het begin leidt snel tot “context confusion“, waarbij de suggesties of de antwoorden van de LLM gebaseerd gaan zijn op stukken informatie die (nog) niet relevant zijn. Het is beter de documentatie geleidelijk toe te voegen, in gelijke tred met de functionaliteit, in plaats van de volledige analyse en achtergrond op voorhand toe te voegen aan de IDE. In het geval van regelgeving: voeg de regels artikel per artikel toe aan de IDE, naarmate de projectontwikkeling vordert, en weersta de verleiding om de hele wettekst op voorhand als “encyclopedische referentie” te integreren in de IDE.

Context rot of context poisoning ontstaat dan weer wanneer de AI een verkeerde weg is ingeslagen,  daarop voortboomt, en uiteindelijk relevantere informatie vergeet zodat het ook moeilijker wordt om ervan te herstellen. “Context quarantining“, het opdelen van het probleem in kleinere deelproblemen elk met hun eigen context, is daarvoor een logische remedie. Dit is ook de weg die de meeste “deep research” of “multi-agentic” systemen inslaan. In een IDE zou dat impliceren dat een AI-systeem de codebase en de documentatie vanaf een zekere grootte zou moeten segmenteren. Hoe dat technisch uitgewerkt kan worden achter de schermen lijkt een uitdaging van formaat, en verschillende IDEs zullen daar in de nabije toekomst waarschijnlijk hun eigen approach voor ontwikkelen.

Een andere frustratie was dat de AI soms code of bestanden verkeerd plaatste of aannam dat bepaalde dingen bestonden. Zo refereerden gegenereerde formules naar variabelen die nog helemaal niet gedefinieerd waren. Dit zorgt bij het testen natuurlijk voor foutmeldingen. We moesten de AI dan bijsturen of zelf extra variabelen invoegen om die referenties af te dekken. Ook kleine zaken, zoals de formattering van documentatie of het wel/niet aanmaken van noodzakelijk imports, vergden manuele correctie. Dit soort inconsistenties tonen aan dat je AI-suggesties niet blindelings kunt vertrouwen. Een developer moet voortdurend valideren of de code die gegenereerd wordt strookt met de bedoeling, en zo niet, onmiddellijk ingrijpen.

publi.codes

We willen ook nog wijzen op het bestaan van publi.codes als eventueel alternatief voor OpenFisca. Recenter en moderner, moeten de regels daar gecodeerd worden in een YAML-formaat, wat veel hanteerbaarder is dan het schrijven van subklassen in Python, en veel leesbaarder voor niet-developers. Men is in ruil daarvoor echter wel beperkt tot de bewerkingen die zijn toegelaten door de achterliggende motor. Pas vanaf de nog in ontwikkeling zijnde versie 2 komen daar mogelijkheden bij om barema’s te encoderen, of abattementen (vrijgestelde bedragen), die in België erg veelvuldig voorkomen.

De huidige versie van publi.codes is bovendien afhankelijk van het NPM ecosysteem dat tegenwoordig regelmatig geplaagd wordt door supply chain aanvallen. Publi.codes v2 zou dan weer gecompileerd worden naar OCaml, een programmeertaal die we bij Smals niet gebruiken. Gezien de kans klein is dat Smals deze programmeertaal zou willen introduceren in haar portfolio (en een ondersteunend team ervoor zou willen uitbouwen), leek het weinig nuttig om voor deze oefening ook publi.codes in de diepte te bekijken. Het valt echter wel op dat op het vlak van UI-componenten, publi.codes wel enkele libraries heeft klaarliggen.

Conclusie

Zowel OpenFisca als publi.codes zijn als platform vooral sterk wanneer je regels kunt modelleren als expliciete, testbare berekeningen. Minder ideaal is het voor regels die vooral draaien op discretionaire beslissingen, vrije interpretatie, bewijswaardering, uitzonderingen zonder heldere parameters, of “case management”-workflows. Het zijn primair reken- en regelsystemen, geen dossierbehandelingsplatformen. Daarmee zijn ze eventueel wel geschikt als motor voor apps die belastingen of uitkeringen op niveau van persoon/huishouden kunnen berekenen (recht op iets + bedrag), of om beleidsimpact te simuleren van eventuele wijzigingen (“wat kost deze hervorming?”, “wie wint/verliest?”). Dat kan voor beleidsmakers én burgers interessant zijn.

Toch is een OpenFisca-project niet snel even opgezet. Conceptueel is OpenFisca enigszins verwarrend voor een developer: hoewel OpenFisca gebruikmaakt van Python-klassen, dienen deze niet om objecten te modelleren, maar om entiteiten, variabelen en berekeningsregels uit de regelgeving declaratief vast te leggen. Gegeven dat er 1 klasse per variabele moet geschreven worden, en er vlotjes tientallen variabelen kunnen meespelen in een fijnmazig wetsartikel, zit men met een snel groeiende stapel code die een uitdaging is om overzichtelijk georganiseerd te krijgen. Daarnaast vergt ook de ontwikkeling van een GUI veel extra werk. Het project mist nog de nodige tooling om deze recurrente problematieken te verlichten. (Het helpt natuurlijk niet wanneer de opdrachtgevende overheid in 2020 plots de kraan dichtdraait, schijnbaar van mening dat open-source projecten per definitie zelfbedruipend kunnen zijn.)

Tot slot kunnen we nog zeggen dat dit experiment tegelijk een nuttige en leerzame reality check was over wat LLMs kunnen bijdragen, en kunnen verknoeien, aan een developer-werkomgeving. Zelf de regie stevig in handen blijven houden en werken met kleine incrementele stapjes, blijft de beste raad. De ene AI tool zal daarbij al wat minder steken laten vallen dan de andere op allerlei vlakken. Het geven van negatieve antwoorden of het detecteren van fouten in de vraagstelling blijft erg uitdagend voor LLMs en dat brengt wat risico met zich mee. AI-assistentie in IDEs evolueert echter razendsnel, en een gelijkaardig experiment zal volgend jaar ongetwijfeld anders verlopen.

Rules As Code betekent zeker niet dat we vandaag een wettekst aan een AI kunnen geven om er een programma te laten uitrollen. Wel zal er op gespecialiseerde fora de komende jaren ongetwijfeld veel aandacht gaan naar de interactie tussen wet, implementatie, en AI-tooling. Vooralsnog blijft de complexiteit van de regelgeving zelf, ook met steeds betere AI, de grootste hinderpaal voor Rules As Code projecten.

(FR) Dans ce Research Talk (en Néerlandais, sous-titres FR sont disponibles), Joachim Ganseman, chercheur chez Smals, est interrogé sur ses expériences avec les systèmes « Rules as Code » (RaC) et leur mise en œuvre au sein du domaine — complexe — de la sécurité sociale. Joachim émet quelques réserves quant à l’applicabilité directe de ces systèmes dans notre contexte. Regardez et écoutez ici pourquoi.

(EN) In this Research Talk (Dutch speaking, EN subtitles available), Joachim Ganseman, researcher at Smals, is interviewed about his experiences with “Rules as Code” (RaC) systems and their implementation within the complex domain of social security. Joachim places some reservations regarding the direct applicability of these systems in our context. Watch and listen here to find out why. 

Sauf indication contraire, cet article fait référence à la législation belge en vigueur au 15 octobre 2025. Les interprétations des textes législatifs dans cet article sont fournies à titre indicatif uniquement et ne font en aucun cas autorité.

Dans une utopie administrative, le parlement vote une loi ou le gouvernement prend une décision qui modifie quelque chose, et le logiciel utilisé pour sa mise en œuvre pratique peut être adapté presque automatiquement à la modification. Le concept d’un lien étroit entre la réglementation et sa mise en œuvre logicielle est également connu sous le nom de Rules as Code, ou RaC.

Au départ, il a surtout été exploré dans le monde juridique, dans les milieux universitaires, dans les incubateurs du secteur, parmi les professionnels du droit ou chez les innovateurs intéressés par la LegalTech. Un nouvel élan est apparu en 2020 lorsque l’OCDE a publié un rapport volumineux dans lequel elle fait le point sur la situation du point de vue des pouvoirs publics, en se référant à des preuves de concept provenant de différents pays. Cela venait à point nommé, car la pandémie de COVID-19 cette même année avait confronté les gouvernements et leurs fournisseurs informatiques à des directives et des mesures en constante évolution à mesure que les connaissances scientifiques sur la maladie progressaient, et à une pression temporelle sans précédent pour mettre en œuvre chaque update le plus rapidement possible. Une technologie capable de faciliter la mise en œuvre harmonieuse de nouvelles réglementations est donc la bienvenue.

Certains pays sont donc passés à la vitesse supérieure. La France est en tête en matière de preuves de concept fonctionnelles, notamment avec les simulateurs Mes Droits Sociaux, LexImpact et divers projets basés sur des publicodes. Des initiatives sont également en cours au Canada, en Australie, en Nouvelle-Zélande et aux Pays-Bas. L’UE a publié un article thématique informatif sur sa plateforme GovTech Connect, mentionnant plusieurs autres sources, et aux États-Unis également, des voix s’élèvent pour attirer l’attention sur ce sujet. Enfin, une étude néerlandaise approfondie nous fournit un aperçu pratique et récent des solutions Rules as Code.

Domaines d’application

Ce serait bien de pouvoir convertir une loi de manière semi-automatique en un logiciel (de préférence correct). Cependant, les expériences menées en Nouvelle-Zélande nous ramènent à la réalité et démontrent de manière convaincante qu’une correspondance parfaite entre la loi et le logiciel correspondant, si tant est qu’elle soit réalisable, est même indésirable dans de nombreux cas.

L’application des règles nécessite en effet une interprétation. Ainsi, la formulation de nombreuses lois est délibérément maintenue quelque peu abstraite, afin de les rendre largement applicables ou d’éviter que des lacunes n’apparaissent trop rapidement lorsque la société évolue. Pour chaque application pratique, ces concepts abstraits doivent être concrétisés. Ce n’est pas toujours facile : quand les petites réparations d’une maison louée sont-elles “de nature structurelle” (et donc à la charge du propriétaire) ? Quand les mesures RGDP sont-elles “suffisantes” ? Une dépense est-elle ou non une “dépense professionnelle déductible” ? Et qui sont exactement ces vagues “autorités compétentes” auxquelles le texte de loi fait référence ? Tout cela fait l’objet de discussions.

Les circulaires ou les décisions administratives permettent parfois aux autorités publiques de clarifier l’interprétation souhaitée, mais il est rare d’aboutir à un ensemble complet et cohérent de règles. En cas d’ambiguïté, une différence minime d’interprétation peut faire toute la différence. Si nous imaginons une conversion entièrement automatique du texte de loi en logiciel, nous risquons de sauter ces étapes d’interprétation ou de les laisser remplir sans beaucoup de finesse par des valeurs par défaut préprogrammées. Tout juriste frémirait à cette idée, et à juste titre.

Rules as Code n’est donc pas la panacée et trouve surtout des applications lorsque les règles sont sans ambiguïté et ne nécessitent que peu d’interprétation, ou lorsque les imprécisions sont acceptables et peuvent être conservées dans le résultat final. L’exemple classique est un ensemble de règles qui peuvent être réduites à un arbre de décision basé sur des critères objectivement calculables. Les applications associées sont, par exemple, les formulaires de demande, les simulateurs ou les modules de calcul. Les réglementations de nature plutôt normative, telles que les règlements de l’UE qui utilisent fréquemment des termes vagues tels que “suffisant”, “adéquat”, “approprié”, “pertinent”, etc. ne s’y prêtent pas, ce que certains universitaires ont judicieusement formulé ainsi : “la justice ne peut être automatisée“.

Obstacles

Dès que l’on commence à transposer la réglementation en code, on se heurte rapidement à la complexité des liens internes entre toutes sortes de lois et de décisions. Un bon exemple est l’âge de la retraite aux Pays-Bas : bien que défini de manière assez simple à l’article 7a de la loi concernée, il affecte ou est cité dans au moins 100 autres lois ou statuts néerlandais. Si l’on y touche, on risque donc rapidement de provoquer un effet domino important.

En outre, le législateur fait preuve de créativité lorsqu’il s’agit de trouver des solutions à certaines situations rares. Il est courant de revoir ou d’élargir les définitions, ou d’ajouter des exceptions ou des conditions supplémentaires. Chaque amendement peut à son tour renvoyer à d’autres règles ou lois, ce qui entraîne toute une série de dépendances.

Prenons le concept de majorité. En théorie, c’est une règle simple : toute personne âgée de 18 ans ou plus est majeure et donc capable d’exercer ses droits civils (art. 488 de l’ancien Code civil). Cependant, ce tout petit article est suivi d’une série d’articles beaucoup plus longs sur les exceptions à cette règle (art. 488/1 et suivants), jusqu’à l’administration (art. 494–502). Si cela ne suffit pas, le juge de paix peut également intervenir (art. 492) et statuer sur une longue liste de capacités qui, au moment de la rédaction du présent document, comprend déjà 42 éléments distincts (art. 492/1 §2 + §3) .

Supposons qu’un service public soit autorisé à octroyer des subventions sur la base d’un règlement qui impose la majorité comme condition et que nous souhaitions créer un site web permettant aux citoyens de vérifier leur éligibilité. Dans ce cas, programmer if (x≥18) n’est pas toujours suffisant. Une personne sous tutelle qui n’est pas autorisée à gérer ses propres finances peut devoir obtenir une autre réponse. Cela n’est pas nécessairement explicitement mentionné dans le règlement relatif aux subventions, mais découle de l’application de la définition de la majorité civile telle qu’elle figure dans le code civil.

Mais ce n’est pas tout : les lois peuvent étendre ou modifier les définitions antérieures. Ainsi, le concept de majorité est élargi dans la loi sur l’intégration sociale : les personnes mineures mariées, enceintes ou ayant des enfants à charge sont assimilées à des personnes majeures (art. 7), mais uniquement pour l’application de cette loi. En résumé : toute personne majeure a plus de 18 ans, mais toutes les personnes âgées de plus de 18 ans ne sont pas pleinement indépendantes, et la notion de majorité peut en outre varier selon le domaine d’application.

L’aspect temporel introduit une dimension de complexité supplémentaire. En effet, toutes ces règles n’ont pas toujours été en vigueur. En Belgique, la majorité à 18 ans n’est entrée en vigueur que le 1er mai 1990 (loi du 19 janvier 1990, publiée au Moniteur belge le 30 janvier 1990). Auparavant, il fallait avoir 21 ans. La tutelle générale mentionnée ci-dessus a été précédée par différents statuts spéciaux, dont la “minorité prolongée” et la “tutelle provisoire”. Ces derniers ont été supprimés en 2014, mais en raison d’une disposition transitoire, ils n’ont disparu dans la pratique que le 1er septembre 2019. Des changements surviennent également en raison de fusions communales, de réformes de l’État, de pays qui n’existent plus, de règles temporaires telles que les mesures de soutien COVID, etc.

Même si une ancienne législation a été abrogée depuis des années, ses effets peuvent encore se faire sentir longtemps. Nous voyons ainsi sur notre déclaration d’impôts de 2025 une déduction pour “cotisations spéciales de sécurité sociale des années 1982 à 1988” (cadre VIII, code 1388-67). Les droits sociaux acquis dans le cadre de statuts ou de régimes qui n’existent plus aujourd’hui continuent également de compter. Si un calcul dépend d’une situation passée et de la législation en vigueur à l’époque, il peut donc être nécessaire d’implémenter dans un logiciel non seulement la réglementation actuelle, mais aussi tout son historique.

Toute cette complexité, même dans des concepts simples, ne peut que donner lieu à des lacunes ou des incohérences. Le Conseil d’État a fort à faire pour conseiller le législateur et corrige régulièrement les erreurs dans les projets de texte. Même dans ce cas, le Moniteur belge doit souvent publier des errata. Le gouvernement est parfois chargé de définir les détails du contenu, mais les arrêtés royaux ou ministériels se font attendre, ce qui crée un vide pendant un certain temps. D’autres fois, la formulation n’est pas assez précise : par exemple, on ne précise pas s’il s’agit de jours calendaires ou de jours ouvrables.

Lorsque des lacunes, des contradictions apparentes ou des interprétations donnent lieu à des discussions, la Cour de cassation doit parfois clarifier certaines choses. Bien que cela ne garantisse pas une réduction de la confusion linguistique à l’avenir, comme en témoigne ce récent arrêt dans lequel il est précisé qu’un véhicule à moteur au sens de la loi sur la circulation routière ne doit pas être compris comme un véhicule à moteur tel que défini dans le code de la route…

Enfin, il existe des cas où le texte de loi lui-même est grammaticalement ambigu. Ainsi, dans l’arrêté d’exécution du Gouvernement de la Région de Bruxelles-Capitale relatif aux travaux exemptés de permis d’urbanisme, il est mentionné à l’article21/1, 3° : “[…] la pose d’isolation […] sur un mur mitoyen ou une façade non visible depuis l’espace public […]”. Il n’est pas clair ici si la phrase subordonnée (“non visible depuis l’espace public”) se rapporte uniquement à la façade ou à la fois à la façade et au mur mitoyen. Sans doute au grand dam de homegrade.brussels, qui doit conseiller les particuliers à ce sujet et qui doit admettre dans sa fiche d’information sur le sujet : “Cet article est sujet à diverses interprétations”.

Cela représente déjà un défi de taille dans le cadre du développement d’applications classiques. La tâche serait-elle plus simple si nous construisions notre application autour d’un framework Rules as Code ? Pas vraiment : un framework RaC peut fournir une méthodologie ou une approche fixe, mais cela ne suffit pas à éliminer la complexité : la même quantité d’informations doit toujours être programmée, et les ambiguïtés continuent de poser les mêmes problèmes. Certains moteurs RaC permettent de détecter les lacunes dans les règles, mais il faut encore décider quoi en faire. Bien définir le projet et fixer des limites reste nécessaire pour éviter d’être submergé par une avalanche de dépendances, de références et d’historique des modifications.

La base : l’analyse législative

Supposons que nous voulions créer un logiciel qui mette en œuvre une certaine législation et qui calcule, par exemple, si vous avez droit à une subvention spécifique et, si oui, à quel montant.

Tout d’abord, il faut trouver un moyen de convertir cette loi en une forme structurée qui facilite la conversion en code. Grâce à une analyse législative, nous essayons de décomposer chaque règle de cette loi en ses différents éléments. Le schéma d’analyse ci-dessous, provenant du ministère néerlandais de l’Intérieur, est générique et prévoit une division en 15 classes :

Les variables sont des caractéristiques qui peuvent varier pour chaque sujet de droit (personne ou entité) : pour une personne, il s’agit par exemple du sexe, du lieu de résidence, du nom, de l’état civil. Les paramètres, en revanche, sont les caractéristiques de la règle qui sont identiques pour tout le monde : un champ d’application, une date de début, une valeur d’indice, etc. Ainsi, une circulaire aura souvent pour objectif d’adapter des paramètres tels que la valeur de l’indice, tandis qu’une loi définira quelles variables peuvent être prises en compte dans l’application d’une règle et dans quelles conditions. Il est parfois difficile de déterminer si un terme relève des variables ou des paramètres. Les créateurs de cette méthode fournissent pour chaque catégorie une description et des exemples qui clarifient la manière dont ils peuvent être exprimés dans un texte législatif.

Prenons l’exemple du droit au congé de maternité, régi par le chapitre IV, art.39 et suivants de la loi sur le travail. En résumé, la règle de base est qu’une femme enceinte a droit à ce congé à partir de 6 semaines avant la date prévue de l’accouchement estimée par le médecin (8 semaines en cas de grossesse multiple), plus 9 semaines après l’accouchement. Une analyse rudimentaire de cette règle selon le schéma ci-dessus peut être commencée comme suit :

• La femme, son employeur et son médecin sont tous des sujets de droit, liés entre eux par une relation de travail ou une relation médecin-patient qui sont des relations juridiques.
• L’une des conditions de cette loi est que la date de l’accouchement soit estimée par un médecin dans un certificat médical remis à l’employeur. Ce certificat est ici un objet juridique.
• Les variables applicables à la femme sont notamment : le nombre d’enfants qu’elle attend, son lieu de résidence, son lieu de travail, la date prévue pour l’accouchement… Elles sont différentes pour chaque femme.
• Les paramètres de cette loi sont notamment les délais minimaux et maximaux mentionnés : 6 semaines, 8 semaines, 9 semaines… Ils sont identiques pour toutes les femmes.
• L’indication de la durée et du lieu précise où et quand la règle s’applique : sur le territoire belge, et depuis les dernières modifications législatives, c.à.d. à partir du 1er juillet 2004 pour la partie prénatale et du 1er mars 2009 pour la partie postnatale du congé de maternité. L’historique des paramètres peut également être consigné. Les variables peuvent également comporter des indications temporelles si elles évoluent dans le temps.

La réglementation effective prévoit notamment des situations exceptionnelles pour les enfants prématurés, malades ou mort-nés, etc. En tenir compte dans l’analyse peut conduire à l’ajout de nombreux paramètres et variables supplémentaires afin de couvrir toutes ces exceptions.

La règle de déduction prend alors la forme d’un calcul, dans lequel :

• l’input consiste en une “situation” décrite comme un ensemble de variables,
• les conditions permettent d’activer ou non certains composants du calcul,
• les paramètres donnent un poids aux composants du calcul,
• l’output peut être une valeur catégorielle ou numérique,
• le calcul peut s’appuyer sur d’autres règles de déduction avec leurs propres paramètres, conditions et variables.

Nous sommes libres de choisir le niveau de granularité ou la profondeur de notre analyse. Nous pouvons pinailler et essayer d’encoder chaque détail de la réglementation, mais nous pouvons tout aussi bien nous contenter de faire quelques généralisations, ne serait-ce que pour éviter que le logiciel final ait plus de boutons qu’un cockpit d’avion. Nous avons donc pris la femme comme point de départ ci-dessus, mais en réalité, la loi parle d’employée. Cela implique un contrat de travail valide. Nous pouvons intégrer cela avec des variables et des conditions supplémentaires, et même avec des règles supplémentaires sur les contrats de travail, mais cela apporte-t-il une valeur ajoutée ? Il peut suffire de laisser les choses telles quelles et d’indiquer dans une clause de non-responsabilité que l’application ne s’applique qu’aux employées.

Traduire correctement la législation en code n’est donc pas chose aisée et nécessite de prendre en compte certains éléments. Il est utile à cet égard d’établir une collaboration étroite entre les juristes, qui peuvent expliquer clairement les règles, et les développeurs de logiciels qui doivent les traduire en code informatique, avec ou sans approche RaC. Il en résulte également de nouveaux profils combinant des compétences juridiques et techniques : nous assistons progressivement à l’émergence de “legal engineers” et de “programmateurs politiques”. 

L’approche Rules as Code

L’objectif d’une approche Rules as Code est de traduire les lois, les règles, les politiques, etc. dans un format structuré compréhensible par une machine. Cela peut ensuite être directement intégré dans des applications ou des sites web. L’idée est que ces applications puissent ainsi être plus facilement adaptées à une réglementation en constante évolution et que les utilisateurs puissent compter sur une plus grande transparence grâce au lien direct avec la législation.

Il n’existe pas de normes internationalement reconnues pour l’analyse législative, ni pour l’encodage des textes législatifs. L’exemple néerlandais ci-dessus est applicable de manière générique, mais cette initiative est encore jeune. Les moteurs Rules as Code existants utilisent d’autres conventions, qui peuvent varier considérablement les unes des autres. Ils définissent généralement leur propre encodage, sous la forme d’un Domain-Specific Language ou d’un Controlled Natural Language, dans lequel la réglementation doit d’abord être convertie. Ce n’est qu’une fois cette étape franchie que d’autres applications peuvent être développées.

L’absence de formats, de modèles et d’ontologies standardisés rend difficile l’adoption de Rules as Code. Entre les différents preuves de concept dans différents pays, parfois même au sein d’un même pays, l’interopérabilité reste encore assez faible. Chaque pays ou chaque département risque ainsi d’utiliser son propre langage, approche ou méthodologie, ce qui entraîne une fragmentation et une duplication des efforts. Idéalement, il faudrait viser un vocabulaire standardisé et des règles publiées dans un format uniforme, afin qu’elles puissent être réutilisées et échangées entre différents systèmes et services publics.

Parmi les outils Rules as Code existants d’une certaine importance, on trouve OpenFisca, PubliCodes, Català et RegelSpraak. Nous nous tenons délibérément à distance des BPMN, CMMN, langages de programmation logiques et rule engines classiques, qui ne sont pas adaptés aux textes juridiques. Dans un prochain article, nous approfondirons notre analyse en nous focalisant sur les outils spécialement conçus pour la législation, et nous en choisirons un pour l’étudier en détail sur le plan technique.

Conclusion provisoire

Les frameworks Rules as Code fournissent une méthode uniforme et générique pour analyser la législation. Ils offrent aux programmeurs une bibliothèque contenant les éléments de base nécessaires pour mettre en œuvre la réglementation et créer des scénarios de test, quel que soit le domaine dans lequel ils travaillent. En analysant la réglementation et en la convertissant en un domain-specific language, celle-ci peut être traitée par un rule engine ou un interpreter. Il est important de noter que cette conversion nécessite pour l’instant un travail humain minutieux et analytique, car elle implique une interprétation. (L’externalisation de cette étape à de grands modèles de langage ne donne pas de résultats entièrement positifs, mais nous y reviendrons dans un prochain article).

Le niveau de détail de nombreuses réglementations rend l’analyse et la conversion vers un format Rules as Code rarement aisée. Si l’on souhaite aboutir à un système complet et cohérent qui tienne compte de nombreuses dépendances et situations exceptionnelles, on se retrouve confronté à une quantité impressionnante de paramètres et de variables. Si les calculs doivent pouvoir être rétroactifs et que l’historique de la législation joue également un rôle, cela ajoute une dimension supplémentaire. Les interdépendances internes entre toutes les règles font que, pour mettre en place une application Rules as Code, il faut rapidement s’attendre à un effort initial important.

L’un des arguments en faveur du Rules as Code est qu’il permettrait de développer certains types d’applications de manière générique pour n’importe quel domaine : eligibility checkers, compliance tools, tax/benefit calculators, formulaires web, simulateurs de calcul, gestion de dossiers, etc. Tant que la législation sous-jacente est suffisamment claire et concrète, une même application template pourrait être utilisée sans trop de modifications dans tous les départements gouvernementaux. Cette idée louable se heurte toutefois à des difficultés pratiques liées à la législation elle-même, qui se réinvente presque dans chaque domaine : il est ainsi difficile de développer des composants communs pour la majorité ou les véhicules à moteur lorsque ces termes ont des définitions différentes dans différentes lois.

Une autre promesse de Rules as Code est que les applications développées sur la base de tels frameworks restent étroitement liées à la législation, ce qui peut également être rendu visible. Ce lien doit offrir des garanties plus transparentes qu’une application est bien conforme à la législation et qu’elle le restera si cette législation venait à changer demain. En outre, il existe un potentiel pour aider à l’élaboration de règles. Un processus itératif dans lequel une version RaC des règles est élaborée parallèlement à la version préliminaire du texte peut permettre de détecter et de combler rapidement les lacunes, voire de faciliter l’analyse politique ex ante en simulant d’abord l’impact de modifications législatives hypothétiques (voir également le rapport de l’OCDE à ce sujet). Il n’en reste pas moins que, même avec le framework RaC, la mise en œuvre de ce processus nécessite les mêmes investissements importants.

Pour rassurer ceux qui craignent que les ordinateurs ne prennent bientôt le contrôle du système judiciaire, nous en sommes encore très loin. Rappelons également que le RGPD, dans son article 22, fixe des limites claires à la prise de décision automatique. En outre, une version codifiée d’une loi n’a pour l’instant aucun statut juridique ni aucune validité légale : seul le texte original de la loi est contraignant. En d’autres termes, même si nous convertissons la réglementation en code, le contrôle humain reste indispensable et le Moniteur belge a toujours le dernier mot.

Affaire à suivre…

Noot: dit artikel refereert naar Belgische wetgeving zoals deze gold op 15 oktober 2025, tenzij waar anders aangeduid. De interpretaties van wetteksten in dit artikel dienen slechts ter illustratie en zijn in geen geval autoritatief.

In een administratief utopia stemt het parlement een wet, of neemt de regering een besluit, dat iets wijzigt, en kan de software gebruikt voor de praktische uitwerking ervan haast automatisch aangepast worden aan de wijziging. Het concept van een nauwe koppeling tussen regelgeving en de softwarematige implementatie ervan, staat ook bekend onder de naam Rules as Code, afgekort RaC.

Initieel werd het vooral verkend in de juridische wereld, in academia, in incubatoren in de sector, onder juridische professionals, of bij innovatoren met interesse in LegalTech. Een hernieuwd elan kwam er in 2020 toen de OESO een lijvig rapport publiceerde waarin ze een stand van zaken geeft vanuit overheidsperspectief, daarbij refererend naar proof-of-concepts uit verschillende landen. Goed getimed, want de COVID-pandemie in datzelfde jaar had overheden en hun IT-leveranciers geconfronteerd met snel wijzigende richtlijnen en maatregelen naarmate de wetenschappelijke kennis over de ziekte toenam, en een ongeziene tijdsdruk om elke update zo snel mogelijk in de praktijk om te zetten. Technologie die een soepele implementatie van nieuwe regulering kan faciliteren, klinkt dan als muziek in de oren.

Sindsdien zijn enkele landen dan ook een versnelling hoger geschakeld. Frankrijk loopt op kop wat betreft werkende proof-of-concepts, waaronder simulatoren op Mes Droits Sociaux, LexImpact, en verscheidene projecten gebaseerd op publicodes. Ook in Canada, Australië, Nieuw-Zeeland en Nederland lopen er initiatieven. De EU publiceerde een informatief thema-artikel op haar GovTech Connect platform met vermelding van verschillende andere bronnen, en ook in de VS gaan stemmen op om er aandacht aan te besteden. Een diepgaande Nederlandse studie tenslotte voorziet ons van een handig en recent overzicht van Rules as Code oplossingen.

Toepassingsdomein

Het klinkt mooi om een wet semi-automatisch te kunnen omzetten in (liefst correcte) software. Ervaringen uit Nieuw-Zeeland zetten ons echter met de voeten op de grond en tonen overtuigend aan dat een 1-op-1 mapping tussen wet en bijhorende software, als dat al haalbaar is, in veel gevallen zelfs onwenselijk is.

De toepassing van regels vereist immers interpretatie. Zo wordt de verwoording van veel wetgeving met opzet enigszins abstract gehouden, om ze breed toepasbaar te maken, of om te voorkomen dat er te snel mazen ontstaan wanneer de samenleving evolueert. Voor elke praktische toepassing moeten die abstracte concepten concreet ingevuld worden. Dat is niet altijd gemakkelijk: wanneer zijn kleine reparaties aan een huurhuis “structureel van aard” (dus voor rekening van de huisbaas)? Wanneer zijn GDPR-maatregelen “voldoende”? Is een uitgave wel of niet een “aftrekbare beroepskost”? En wie zijn nu exact die vage “bevoegde instanties” waar de wettekst naar verwijst? Allemaal voer voor discussie.

Via omzendbrieven of rulings wordt de gewenste interpretatie soms wel verder verduidelijkt van overheidswege, maar dan nog kom je zelden tot een volledige en sluitende verzameling regels. Is er onduidelijkheid, dan kan een miniem verschil in interpretatie een zaak maken of kraken. Beelden we ons een volautomatische omzetting van wettekst naar software in, dan riskeren we deze interpretatieve stappen over te slaan of zonder veel finesse te laten invullen door voorgeprogrammeerde default-waarden. Elke jurist zal huiveren bij dat idee, en terecht.

Rules as Code is dus niet zaligmakend en vindt vooral toepassingen waar regels ondubbelzinnig zijn en weinig interpretatie behoeven, of wanneer vaagheden aanvaardbaar zijn en behouden kunnen blijven in het eindresultaat. Het klassieke voorbeeld is een set regels die te herleiden zijn tot een beslisboom op basis van objectief berekenbare criteria. Applicaties die daarmee gepaard gaan zijn bijvoorbeeld aanvraagformulieren, simulatoren of rekenmodules. Regelgeving die eerder normatief van aard is, zoals EU-verordeningen met hun veelvuldig gebruik van vage termen zoals “voldoende”, “adequaat”, “geschikt”, “relevant”, … leent zich er niet toe – wat enkele academici gevat verwoord hebben als: “rechtvaardigheid kan men niet automatiseren”.

Hindernissen

Eens men begint aan de oefening om regelgeving om te zetten in code, botst men al snel op de complexe interne verwevenheden tussen allerlei wetten en besluiten. Een mooie illustratie is de Nederlandse pensioenleeftijd: zelf vrij rechttoe rechtaan gedefinieerd in artikel 7a van de betreffende wet, heeft ze impact op, of wordt ernaar verwezen in, minstens 100 andere Nederlandse wetten of statuten. Als daaraan gemorreld wordt, riskeer je dus al snel grote domino-effecten.

Daarnaast komt de wetgever creatief uit de hoek als er oplossingen gevonden moeten worden voor bepaalde zeldzame situaties. Het herbekijken of uitbreiden van definities, of toevoegen van uitzonderingsbepalingen of extra voorwaarden, is courante praktijk. Elk amendement kan op zijn beurt verwijzen naar weer andere regels of wetten, wat een hele keten aan afhankelijkheden met zich meebrengt.

Neem het concept van meerderjarigheid. In theorie is dat een eenvoudige regel: wie 18 is of ouder, is meerderjarig en bijgevolg handelingsbekwaam (art. 488 oud B.W.). Dat piepkleine artikeltje wordt echter gevolgd door een resem veel langere artikels over de uitzonderingen daarop (art.488/1 e.v.), tot en met bewindvoering (art. 494–502). Als dat niet voldoet, kan ook de vrederechter ingrijpen (art.492) en oordelen over een waslijst aan bekwaamheden die op moment van schrijven al 42 afzonderlijke items bevat (art.492/1 §2 + §3).

Stel dat een overheidsdienst subsidies mag uitdelen op basis van een reglement dat meerderjarigheid als voorwaarde stelt, en we willen een website bouwen waar burgers een eligibility check kunnen doen, dan is if (x≥18) programmeren niet altijd voldoende. Iemand die onder bewindvoering staat en zijn eigen geldzaken niet mag beheren, moet mogelijk alsnog een ander antwoord krijgen. Dat staat niet noodzakelijk expliciet in dat subsidiereglement, maar is een gevolg van het hanteren van de definitie van meerderjarigheid uit het burgerlijk wetboek.

Daarmee is de kous nog niet af: wetten kunnen eerdere definities uitbreiden of wijzigen. Zo wordt het concept van meerderjarigheid in de wet op de Maatschappelijke Integratie verruimd: minderjarigen die gehuwd zijn, zwanger zijn, of kinderen ten laste hebben worden gelijkgesteld aan meerderjarig (Art. 7) – maar enkel voor de toepassing van die wet. Samengevat: elke meerderjarige is 18+, maar niet elke 18+er is ten volle zelfstandig meerderjarig, en wat begrepen mag worden onder meerderjarigheid kan bovendien per toepassingsgebied nog verschillen.

Het temporele aspect voegt daar nog een hele dimensie van complexiteit aan toe. Niet al deze regels golden immers altijd. De meerderjarigheid op 18 jaar is in België pas in werking getreden op 1 mei 1990 (wet van 19 januari 1990, gepubliceerd in het Belgisch staatsblad op 30 januari 1990). Voordien moest men 21 zijn. De hierboven aangehaalde algemene bewindvoering werd dan weer voorafgegaan door verschillende speciale statuten, waaronder “verlengde minderjarigheid” en “voorlopige bewindvoering”. Deze werden afgeschaft in 2014, maar door een overgangsbepaling doofden ze pas uit in de praktijk op 1 september 2019. Wijzigingen gebeuren ook door gemeentelijke fusies, staatshervormingen, landen die niet meer bestaan, tijdelijke regels zoals de COVID-steunmaatregelen, …

Al is oude wetgeving al jaren opgeheven, de effecten ervan kunnen nog lang nazinderen. Zo zien we op onze belastingaangifte in 2025 nog een aftrekpost voor “bijzondere bijdragen voor de sociale zekerheid van de jaren 1982 tot 1988” (vak VIII, code 1388-67). Ook sociale rechten opgebouwd in statuten of regimes die vandaag niet meer bestaan, tellen nog steeds mee. Als een berekening afhangt van een situatie uit het verleden en de destijds geldende wetgeving, kan het dus nodig zijn om in een applicatie naast de huidige regelgeving ook de hele voorgeschiedenis ervan te implementeren.

Met al deze complexiteit in zelfs eenvoudige concepten, kan het niet anders of er duiken onvolledigheden of inconsistenties op. De Raad van State heeft haar handen vol met het adviseren van de wetgever, en haalt regelmatig fouten uit ontwerpteksten. Zelfs dan moet het Staatsblad vaak nog errata publiceren. Soms wordt de invulling van inhoudelijke details overgelaten aan de regering, maar laten de Koninklijke of ministeriële besluiten lang op zich wachten, waardoor er een tijd lang een vacuüm ontstaat. Andere keren is men niet exact genoeg in de verwoording: men verduidelijkt bijvoorbeeld niet of men spreekt over kalenderdagen of werkdagen.

Daar waar onvolledigheid, ogenschijnlijke tegenspraak of interpretatie voor discussie zorgt, moet het Hof van Cassatie soms één en ander ophelderen. Al is dat geen garantie op minder spraakverwarring in de toekomst, getuige dit recente arrest waarin ze aanstippen dat een motorvoertuig in de Wegverkeerswet, niet begrepen mag worden als een motorvoertuig zoals gedefinieerd in de Wegcode…

Tot slot zijn er nog gevallen waar de wettekst zelf grammaticaal ambigu is. Zo wordt in het uitvoeringsbesluit van de Brusselse Hoofdstedelijke Regering over werken die vrijgesteld zijn van stedenbouwkundige vergunning, vermeld in art. 21/1, 3° lid: “[…] de plaatsing van isolatie […] op een mandelige muur of een gevel die niet zichtbaar is vanaf de openbare ruimte […]”. Het is hier onduidelijk of de bijzin (aangevat met die) enkel betrekking heeft op de gevel, of zowel op de gevel als op de gedeelde muur. Ongetwijfeld tot ergernis van homegrade.brussels, dat particulieren hierover moet adviseren, en in haar informatiefiche over het onderwerp moet toegeven: “Dit artikel is voor verschillende interpretaties vatbaar”.

Dit alles is bij klassieke applicatie-ontwikkeling al een hele kluif. Wordt het dan eenvoudiger als we onze app bouwen rond een Rules as Code-framework? Niet echt: een RaC-framework reikt misschien een vaste methodiek of werkwijze aan, maar dat neemt de complexiteit niet weg: dezelfde karrevracht informatie moet er nog steeds ingeprogrammeerd worden, en ambiguïteiten blijven voor dezelfde problemen zorgen. Sommige RaC-engines zullen toelaten om lacunes in de regels te detecteren, maar dan nog moet je beslissen wat je ermee doet. Het project goed afbakenen en grenzen stellen is nog steeds noodzakelijk, om te vermijden overdonderd te worden door een lawine van afhankelijkheden, verwijzingen, en wijzigingshistoriek.

De basis: wetsanalyse

Stel dat we een app willen maken die een bepaalde wetgeving implementeert, en bijvoorbeeld berekent of je recht hebt op een specifieke subsidie en zo ja, hoeveel.

Allereerst is dan een manier nodig om die wet om te zetten in een gestructureerde vorm die de omzetting naar code faciliteert. Via een wetsanalyse trachten we elke regel uit die wet te ontleden in haar onderdelen. Het analyseschema hieronder, afkomstig van het Nederlands ministerie van Binnenlandse Zaken, is generiek toepasbaar en voorziet een opdeling in 15 klassen:

De variabelen zijn eigenschappen die voor elk rechtssubject (persoon of entiteit) kunnen verschillen: voor een persoon zijn dat bijvoorbeeld het geslacht, de woonplaats, de naam, de burgerlijke staat. De parameters daarentegen zijn de eigenschappen van de regel die gelijk zijn voor iedereen: een toepassingsgebied, een startdatum, een indexwaarde, … Zo zal een omzendbrief vaak tot doel hebben om parameters zoals de indexwaarde aan te passen, en zal een wet definiëren welke variabelen onder welke voorwaarden bij de toepassing van een regel in rekening gebracht mogen worden. Het is soms moeilijk te beoordelen of een term nu onder de variabelen of de parameters valt. De makers van deze methode geven bij elke klasse een omschrijving en voorbeelden die verduidelijken hoe ze uitgedrukt kunnen worden in een wettekst.

Nemen we als voorbeeld het recht op het moederschapsverlof, geregeld in hoofdstuk IV, art. 39 e.v. van de Arbeidswet. De basisregel daarvan is, bondig samengevat, dat een zwangere vrouw recht heeft op dit verlof vanaf 6 weken vóór de door de arts geschatte datum van de bevalling (8 weken bij meerlingen), plus 9 weken na de bevalling. Een rudimentaire analyse van deze regel volgens bovenstaand schema kunnen we als volgt aanvangen:

• De vrouw, haar werkgever en haar arts zijn allen rechtssubjecten, met elkaar verbonden door een arbeidsrelatie resp. arts-patiëntrelatie die rechtsbetrekkingen zijn.
• Een van de voorwaarden in deze wet is dat de bevallingsdatum is ingeschat door een arts in een geneeskundig attest dat aan de werkgever wordt overgemaakt. Dat attest is hier een rechtsobject.
• De variabelen van toepassing op de vrouw zijn onder andere: hoeveel kinderen ze verwacht, haar woonplaats, arbeidsplaats, bevallingsdatum… dit is voor elke vrouw anders.
• Parameters van deze wet zijn o.a. de minimum- en maximumtermijnen waarvan sprake: 6 weken, 8 weken, 9 weken, … die zijn gelijk voor elke vrouw.
• Tijds– en plaatsaanduiding zeggen waar en wanneer de regel geldt: op Belgisch grondgebied, en sinds de laatste wetswijzigingen vanaf 1 juli 2004 voor het prenatale en 1 maart 2009 voor het postnatale deel van het moederschapsverlof. De voorgeschiedenis van parameters kan ook worden vastgelegd. Variabelen kunnen ook tijdsaanduidingen hebben als ze evolueren doorheen de tijd.

De eigenlijke regelgeving voorziet o.a. nog in uitzonderingssituaties voor kinderen die te vroeg, ziek, of levenloos geboren worden,… Dat meenemen in de analyse kan leiden tot de toevoeging van vele extra parameters en variabelen om al deze uitzonderingen te vatten.

De afleidingsregel neemt dan de vorm aan van een berekening, waarbij:

• de input bestaat uit een “situatie” die beschreven wordt als een verzameling variabelen,
• de voorwaarden toelaten om bepaalde componenten van de berekening te activeren of niet,
• de parameters aan componenten van de berekening een gewicht geven,
• de output zowel een categorische als numerieke waarde kan zijn,
• de berekening kan steunen op andere afleidingsregels met hun eigen parameters, voorwaarden en variabelen.

Het staat ons vrij om te kiezen hoe granulair we daarin willen zijn, of hoe diep we willen gaan in onze analyse. We kunnen pietje precies zijn en elk detail van de regelgeving proberen encoderen, maar even goed kunnen we vrede nemen met het maken van enkele veralgemeningen, al was het maar om te vermijden dat de uiteindelijke app meer knopjes heeft dan een vliegtuigcockpit. Zo namen we hierboven de vrouw als startpunt, maar eigenlijk spreekt de wet van werkneemster. Dat impliceert een geldig arbeidscontract. Dat kunnen we integreren met extra variabelen en voorwaarden, en zelfs met extra regels over arbeidscontracten, maar biedt dat ook meerwaarde? Het kan voldoende zijn om het zo te laten en in een disclaimer te zeggen dat de app enkel van toepassing is voor werkneemsters.

Wetgeving correct in code vertalen is dus niet eenvoudig, en vergt de nodige afwegingen. Het is daarbij nuttig om een nauwe samenwerking op te zetten tussen juristen, die de regels helder kunnen uitleggen, en de software-ontwikkelaars die dat in code moeten gieten, met of zonder RaC-framework. Daaruit komen ook nieuwe profielen voort met zowel juridische als technische vaardigheden: we zien stilaan “legal engineers” en “beleidsprogrammeurs” opduiken. 

de Rules as Code aanpak

Het opzet van een Rules as Code benadering is om wetten, regels, policies, … te hertalen in een gestructureerd formaat dat door een machine begrepen kan worden. Dit kan dan op zijn beurt direct geïntegreerd worden in applicaties of websites. Het idee is dat deze applicaties zo gemakkelijker kunnen aangepast worden aan snel evoluerende regelgeving, en dat ook gebruikers ervan door de directe link met de wetgeving op meer transparantie kunnen rekenen.

Er bestaan geen internationaal aanvaarde standaarden voor wetsanalyse, noch voor encodering van wettekst. Het Nederlandse voorbeeld hierboven is generiek toepasbaar, maar is nog een jong initiatief. Bestaande Rules as Code engines hanteren andere conventies, die sterk van elkaar kunnen verschillen. Ze definiëren meestal hun eigen encodering, in de vorm van een Domain-Specific Language of Controlled Natural Language, waarin de regelgeving eerst omgezet moet worden. Pas als die stap is gebeurd, kunnen er verder applicaties op worden gebouwd.

Het gebrek aan gestandaardiseerde formaten, modellen en ontologieën bemoeilijkt de adoptie van Rules as Code. Tussen de verschillende proof-of-concepts in verschillende landen, soms ook binnen hetzelfde land, is de interoperabiliteit nog steeds vrij laag. Ieder land of ieder departement dreigt zo een eigen taal, aanpak of methodiek te gaan hanteren, wat leidt tot fragmentatie en dubbel werk. Idealiter zou gestreefd moeten worden naar een gestandaardiseerd vocabularium, en regels gepubliceerd in een uniform formaat, zodat ze hergebruikt en uitgewisseld kunnen worden tussen verschillende systemen en overheidsdiensten.

Onder de bestaande Rules as Code tools van enige grootte vinden we OpenFisca, PubliCodes, Català en RegelSpraak. We houden met opzet wat afstand van BPMN, CMMN, logische programmeertalen en klassieke rule engines, die niet toegespitst zijn op juridische teksten. In een volgend artikel verdiepen we onze analyse met een focus op tools die wel specifiek gebouwd zijn voor wetgeving, waarbij we er eentje zullen kiezen om technisch in detail te bekijken.

Tussentijdse conclusie

Rules as Code frameworks voorzien in een uniforme, generieke manier om aan wetsanalyse te doen. Voor programmeurs bieden ze een library met fundamentele bouwblokken om regelgeving te implementeren en testscenario’s op te zetten, ongeacht het domein waarin men actief is. Door de regelgeving te analyseren en om te zetten naar een domain-specific language, kan die door een rule engine of interpreter verwerkt worden. Belangrijk te noteren is dat deze omzetting vooralsnog minutieus analytisch mensenwerk vergt, omdat er interpretatie bij komt kijken. (Deze stap uitbesteden aan Large Language Models leidt niet tot onverdeeld positieve resultaten, maar daarover meer in een volgend artikel).

De mate van detail in veel regelgeving, maakt een analyse en omzetting naar een Rules as Code-formaat zelden een sinecure. Wil men tot een compleet en sluitend systeem komen dat rekening houdt met vele afhankelijkheden en uitzonderingssituaties, dan wordt men geconfronteerd met overdonderende hoeveelheden parameters en variabelen. Als berekeningen retroactief moeten kunnen zijn en ook de voorgeschiedenis van de wetgeving een rol speelt, komt daar nog een extra dimensie bij. De interne verwevenheden tussen alle regels maken dat men, om een Rules as Code-app van de grond te krijgen, al snel aankijkt tegen een grote initiële inspanning.

Eén van de argumenten voor Rules as Code is dat men bepaalde soorten apps generiek zou kunnen ontwikkelen voor eender welk domein: eligibility checkers, compliance tools, tax/benefit calculators, webformulieren, rekensimulatoren, dossierbeheer,… Zolang de onderliggende wetgeving maar duidelijk en concreet genoeg is, zou dan eenzelfde template-app zonder veel aanpassingen over de grenzen van overheidsdepartementen heen benut kunnen worden. Dit lovenswaardige idee stuit in de praktijk echter op moeilijkheden door de wetgeving zelf, die zichzelf haast heruitvindt in elk domein: zo kan je moeilijk gedeelde componenten ontwikkelen voor meerderjarigheid of motorvoertuigen als die termen verschillende definities hebben in verschillende wetten.

Een andere belofte van Rules as Code is dat apps ontwikkeld op basis van zulke frameworks een nauwe koppeling behouden met de wetgeving, die ook zichtbaar gemaakt kan worden. Deze koppeling moet transparantere garanties bieden dat een app wel degelijk conformeert aan de wetgeving, en dat dat ook zo blijft als die wetgeving morgen wijzigt. Daarnaast is er potentieel om te helpen bij het opstellen van regels. Een iteratief proces waarbij een RaC-versie van de regels wordt ontwikkeld in parallel met de ontwerpversie van de tekst, kan het mogelijk maken om vroegtijdig lacunes op te sporen en te verhelpen, of kan zelfs ex ante beleidsanalyse faciliteren door de impact van hypothetische wetswijzigingen eerst te simuleren (zie daarvoor ook het OESO-rapport). Maar ook hier komt men er niet onderuit dat de uitwerking daarvan, ook mét RaC-framework, dezelfde grote investeringen vergt.

Wie vreest dat computers het rechtssysteem binnenkort gaan overnemen kunnen we dus geruststellen, daar zijn we nog heel ver van weg. We herinneren ook nog even aan de GDPR, die in art.22 duidelijke grenzen stelt aan automatische besluitvorming. Daarnaast heeft een gecodeerde versie van een wet vooralsnog geen juridische status of rechtsgeldigheid – alleen de oorspronkelijke geschreven wettekst is bindend. Met andere woorden, zelfs al zetten we regelgeving om in code, is behoud van menselijk overzicht nog steeds een must, en heeft het Staatsblad nog steeds het laatste woord.

Wordt vervolgd!

Les services numériques doivent non seulement être rentables, mais également robustes : ils doivent continuer à fonctionner si certains fournisseurs ou éléments de base font défaut pour une raison quelconque. Il ne s’agit pas uniquement d’une question purement technique, d’un enfermement propriétaire (vendor lock-in) ou d’architecture multicloud. Nous assistons une fois de plus à l’émergence de questions fondamentales d’indépendance, de sécurité et d’autonomie stratégique : la souveraineté numérique est tendance.

On comprend aisément pourquoi : avec un revirement politique d’une ampleur sans précédent, la réputation des États-Unis en tant que partenaire commercial fiable s’est volatilisée en un temps record. Du jour au lendemain, un service peut être interrompu ou des droits de douane peuvent être introduits sans raison valable. Quiconque développe ou gère des infrastructures IT critiques en tremble rien qu’à l’idée. Et l’autonomie vaut soudain à nouveau son pesant d’or.

Piliers stratégiques

Le cœur de la souveraineté numérique réside dans la capacité à choisir, déployer et gérer des solutions technologiques sans dépendances externes étendues. Ces dépendances sont souvent plus profondes que nous ne le pensons, comme l’a démontré une expérience intéressante du journaliste de Gizmodo, Kashmir Hill, il y a quelques années. La dépendance technologique représente toujours un risque. Afin de le minimiser, nous pouvons entre autres :

• Investir dans le développement local et open source des technologies
• Construire nous-même des infrastructures robustes et décentralisées
• Développer nos propres compétences et capacités technologiques
• Inclure des conditions d’interopérabilité, de migration de données, de flexibilité, d’interruption, etc. dans des clauses contractuelles et les marchés publics.
• …

En matière de développement logiciel pratique également, les choix qui favorisent l’agilité technologique présentent un avantage :

• Choisir des normes ouvertes et des API robustes et standardisées
• Développer des solutions non seulement modulaires et évolutives, mais également agnostiques vis-à-vis du cloud
• Implémenter des middleware capables de relier différentes technologies
• Prêter attention à la portabilité, à la compatibilité multiplateforme et à la compatibilité entre navigateurs
• …

La souveraineté sur les données est également très importante. Une souveraineté numérique exige de conserver un contrôle maximal sur la collecte, le stockage, le traitement et la protection des données. Cela peut se faire en organisant le stockage et le traitement des données localement, de préférence en appliquant des mécanismes solides de gouvernance des données, ou en les confiant à un tiers qui offre les garanties nécessaires et opère dans le cadre d’une législation compatible.

La Belgique se débrouille plutôt bien en matière d’autonomie infrastructurelle, avec le cloud gouvernemental G-Cloud et le réseau Belnet, entre autres.

Le rôle de l’open source

Les technologies open source, en tant que vecteurs d’indépendance technologique, sont des éléments fondamentaux de la souveraineté numérique. Elles offrent une totale transparence du code, permettent la modification ou le propre développement, et diminuent la dépendance vis-à-vis des géants technologiques étrangers.

Cependant, cela a également un coût. L’utilisation de logiciels open source et de normes ouvertes implique de fournir soi-même l’ensemble du support, de la formation, des mises-à-jour, de la compatibilité, du débogage, etc. En échange de l’autonomie, il faut inclure un éventail de tâches connexes. Cela implique notamment un investissement dans la gestion active, ainsi que la maintenance et le développement des connaissances. Les acteurs commerciaux proposant des solutions propriétaires s’en chargent généralement.

Devenir totalement autonome est donc généralement impossible. Il existe un cas d’étude bien connu, celui de la ville de Munich, qui a ambitieusement basculé en 2006 vers un environnement Linux développé en interne, mais qui, en raison de problèmes persistants de compatibilité et de l’augmentation des coûts de gestion qui en découle, a mis fin au programme en 2017 pour revenir à un environnement Microsoft standardisé.

Chez nos voisins

L’Allemagne est une fervente partisane de la souveraineté numérique depuis longtemps. L’Open Source Business Alliance allemande utilise même le terme dans son slogan. L’expérience munichoise a donné naissance à l’actuel Open Source Programme Office de la ville. Le niveau fédéral allemand encourage également l’indépendance technique, notamment :

• Des projets propres tels que Sovereign Cloud Stack (actuellement en transformation après la fin du financement),
• Le Sovereign Tech Fund, qui fournit des fonds pour maintenir les composants open source essentiels,
• Le Zentrum Digitale Souveränität (ZenDis), qui aide les gouvernements à réduire leurs dépendances technologiques.

Ce dernier investit également avec succès dans deux projets propres :

• La plateforme OpenCode, où les services publics peuvent publier et partager leur code avec d’autres,
• L’environnement de travail administratif OpenDesk, qui inclut également des options typiques pour les entreprises telles que l’authentification unique et les intégrations entre les réunions, les « chats », le calendrier et les courriers électroniques.
  

La France n’est pas en reste non plus. Plusieurs initiatives en faveur de la souveraineté numérique sont menées par la Direction interministérielle du Numérique (DINUM). Ils comptent également leur propre dépôt sous la forme de code.gouv.fr. En outre, ils développent de manière proactive de nouvelles applications dans leur propre incubateur. Cela a donné naissance à des projets tels que La Suite Numérique, une suite enterprise level de bureautique qui offre des fonctionnalités telles que le chat vidéo, les webinaires et le transfert de fichiers, et qui est en cours d’extension pour inclure des traitements de texte et des tableurs. La France s’est également engagée dans une stratégie de cloud computing la plus indépendante possible et, tout aussi important, elle s’efforce de motiver et de former ses fonctionnaires par le biais de la communauté des Blue Hats. Du côté des entreprises, l’union des entreprises du logiciel libre et du numérique ouvert (CNLL) s’est engagé en faveur de la souveraineté numérique.

Ce qui est frappant à la fois avec l’OpenDesk allemand et La Suite Numérique française, c’est qu’ils sont tous deux également disponibles en anglais. Même dans le contexte gouvernemental, on prend de plus en plus conscience que les initiatives open source ont de meilleures chances de succès si l’on investit de manière proactive dans l’internationalisation. Plus prometteur encore, DINUM et ZenDis ont commencé une collaboration concrète avec une application de prise de notes développée conjointement. Cette dernière a été présentée lors du dernier FOSDEM, la grand-messe annuelle des développeurs open source à Bruxelles, où les collaborations gouvernementales étaient à l’honneur.

Le tandem franco-allemand est un signe prometteur de la volonté de l’Europe de s’unir pour promouvoir la souveraineté numérique. Nous savons déjà que les Pays-Bas souhaitent se joindre à cette collaboration. En effet, le débat social y est également bien vivant, même à la Seconde Chambre, avec des discussions sur les services cloud ou le DNS. L’Organisation néerlandaise pour la recherche scientifique appliquée (TNO) a publié un long rapport sur la souveraineté numérique, les universités en font un sujet de discussion et le monde des affaires y prête également attention. La souveraineté numérique est à l’ordre du jour à tous les niveaux de gouvernement.

Le rôle de l’Europe

L’Union européenne a un intérêt stratégique évident dans la souveraineté (numérique). Les éléments clés à cet égard sont le récent Digital Markets Act (DMA) et le Digital Services Act (DSA). Ces deux cadres législatifs visent à limiter le pouvoir des géants technologiques étrangers et à rendre le « terrain de jeu » plus équitable et transparent pour les entreprises européennes. L’UE souhaite ainsi renforcer son autonomie stratégique en établissant des règles claires en matière de gestion des données et des plateformes, rendant les États membres européens moins vulnérables aux dépendances extérieures. Le Cybersecurity Act et la directive NIS2 devraient garantir que la sécurité et la fiabilité ne soient pas compromises.

L’UE entreprend également de nombreuses initiatives pertinentes, mais toutes ne décollent pas tout aussi facilement. La fragmentation européenne est une vieille plaie. Les petits projets restent souvent petits et, une fois le financement terminé, ils se transforment en abandonware. Par exemple, il est impossible de savoir si la nouvelle European Open Source Academy survivra à la fin de son cycle de financement en 2027. D’autre part, les consortiums à grande échelle ont de nombreux problèmes de coordination et de contrôle. Le projet GAIA-X a ainsi acquis la réputation d’être plus une histoire de mémos que de démos, si bien que les nouveaux projets tels qu’OpenEuroLLM sont également accueillis avec un certain scepticisme. Le déploiement des European Data Spaces dans divers domaines devrait favoriser la souveraineté sur les données. Cela deviendra obligatoire pour la santé (EHDS), qui pourrait insuffler un nouvel élan. Cela ne suffit cependant pas à apaiser les inquiétudes : le rapport complet EuroStack de la Bertelsmann Stiftung présente même à l’UE une vision plus ambitieuse sur un plateau d’argent.

Sous l’égide de l’Europe Interopérable, on retrouve l’Open Source Observatory and Repository (OSOR), en plus de Public Sector Techwatch et GovTech Connect. Ils surveillent l’utilisation de l’open source dans les administrations gouvernementales européennes depuis plus de 15 ans maintenant, et encouragent les partenariats et la réutilisation. L’Open Source Solutions Catalogue récemment lancé devrait permettre aux pays de réutiliser plus facilement les solutions des uns et des autres. Ils publient également des rapports, des études de cas, des catalogues nationaux (dans lesquels nous trouvons ict-reuse.be) et une lettre d’information. Les gouvernements qui souhaitent mettre en place leur propre Open Source Program Office (OSPO) afin de contribuer activement aux projets open source tels que celui de l’UE, y trouvent le soutien nécessaire. Les Pays-Bas sont déjà convaincus. Si les autorités belges veulent contribuer visiblement à la souveraineté numérique, voilà une excellente occasion.

Conclusion

La souveraineté numérique est plus qu’un choix technique. C’est une stratégie continue pour retrouver un pouvoir d’agir dans un monde numérique hautement interconnecté où les éléments fondamentaux peuvent soudainement changer. Nous ne voulons pas nous contenter de consommer la technologie, mais aussi la façonner, la comprendre et la contrôler activement. Cela nous permettrait de réduire les dépendances externes et les risques qui en découlent. La pensée et la coopération européennes offrent des possibilités de synergies.

L’autonomie technologique nécessite un écosystème technologique sain. Une attention constante au capital humain et au développement des connaissances est indispensable. Pour y parvenir de manière durable, les initiatives de soutien doivent bénéficier des ressources nécessaires :

• Développer de manière proactive des alternatives technologiques, qui anticipent la demande,
• Participer à l’échange de connaissances, à des évènements et réseauter, avec des pairs, des institutions du savoir, des pays voisins, avec l’UE, etc.
• Investir ou participer activement aux solutions open source existantes que l’on réutilise,
• Construire des communautés autour de projets propres,
• Investir dans un design attrayant et l’intuitivité des solutions propres,
• Rendre sa propre solution disponible en dehors de ses murs : publier en open source, intégrer dans des catalogues, ajouter une documentation et une traduction anglaise, etc.
• Travailler sur la notoriété de la marque : sites web, promotion, marketing, salons professionnels, médias (sociaux), etc.
• …

Les personnes intéressées par ce thème peuvent suivre les organisations et les initiatives mentionnées dans cet article sur les médias sociaux ou à travers leurs lettres d’information. Pour une analyse approfondie, le rapport EuroStack mentionné ci-dessus est intéressant. Si vous cherchez des alternatives pour les dépendances dans vos propres projets, european-alternatives.eu, euro-stack.com ou alternativeto.net sont de bons points de départ. Enfin, la souveraineté numérique est un effort d’équipe, n’hésitez donc surtout pas à partager d’autres sources, projets ou liens intéressants dans les commentaires ci-dessous !

______________________

Ce post est une contribution de Joachim Ganseman, consultant IT chez Smals Research. Cet article est écrit en son nom propre et n’impacte en rien le point de vue de Smals.

Digitale dienstverlening moet niet alleen kostenefficiënt zijn, maar ook robuust: het moet blijven werken als bepaalde toeleveranciers of bouwblokken het laten afweten, om welke reden dan ook. Dat is niet alleen een louter technisch vraagstuk van vendor lock-in of multicloud architectuur. We zien fundamentele kwesties rond onafhankelijkheid, veiligheid en strategische autonomie opnieuw ter sprake komen: Digitale Soevereiniteit is hot.

De aanleiding is niet ver te zoeken: met een beleidsomslag van jewelste is de reputatie van de VS als betrouwbare handelspartner in recordtempo verdampt. Zonder aanleiding kan van de ene dag op de andere een dienstverlening stopgezet, of een handelstarief ingevoerd worden. Wie kritische infrastructuur en IT ontwikkelt of beheert, trekt lijkbleek weg van het idee alleen al. En zo is zelfredzaamheid plots weer goud waard.

Strategische pijlers

De kern van digitale soevereiniteit ligt in het kunnen kiezen, implementeren en beheren van technologische oplossingen zonder verregaande externe afhankelijkheden. Die afhankelijkheden zitten dieper dan we vaak denken, zoals enkele jaren geleden nog gedemonstreerd in een interessant experiment van Gizmodo journaliste Kashmir Hill. Technologische afhankelijkheid vormt altijd een risico. Om dat te minimaliseren kunnen we onder andere:

• Investeren in lokale en open-source technologie-ontwikkeling
• Zelf robuuste, gedecentraliseerde infrastructuren opbouwen
• Eigen technologische vaardigheden en capaciteiten uitbouwen
• Voorwaarden qua interoperabiliteit, data-migratie, flexibiliteit, stopzetting, … opnemen in contractuele clausules en openbare aanbestedingen
• …

Ook bij praktische software-ontwikkeling hebben keuzes die technologische wendbaarheid bevorderen een streepje voor:

• Verkies open standaarden en robuuste, gestandaardiseerde APIs
• Ontwikkel niet alleen modulair en schaalbaar maar ook cloud-agnostisch
• Implementeer eventueel middleware die verschillende technologieën kan overbruggen
• Besteed aandacht aan portabiliteit, cross-platform en cross-browser compatibiliteit
• …

Daarnaast is ook data-autonomie van groot belang. Zo vereist digitale soevereiniteit dat men maximale controle over data-verzameling, -opslag, -verwerking en -bescherming behoudt. Dat kan door de data-opslag en -verwerking lokaal te organiseren, liefst met toepassing van degelijke data governance mechanismes, of door ze bij een derde partij onder te brengen die de nodige garanties biedt en tenminste onder een compatibele wetgeving opereert.

Het mag gerust gezegd worden dat België het op het vlak van infrastructurele autonomie, met onder andere de overheidscloud Gcloud en Belnet, best goed doet.

De rol van open-source

Open-source technologieën zijn, als enablers van technologische onafhankelijkheid, fundamentele bouwstenen voor digitale soevereiniteit. Ze bieden volledige transparantie van code, geven de mogelijkheid tot aanpassing of eigen ontwikkeling, en ze verminderen de afhankelijkheid van buitenlandse technologiereuzen.

Dat heeft echter ook een kostenplaatje. Wie in eigen beheer open-source software en open standaarden wil aanwenden, moet ook zelf voorzien in alle ondersteuning, opleiding, upgrades, compatibiliteit, eventueel debuggen, etc. In ruil voor autonomie moet je een heel takenpakket mee opnemen in de marge. Dat impliceert dat je moet willen investeren in actief beheer, onderhoud en kennisopbouw. Commerciële spelers met bedrijfseigen oplossingen ontzorgen je daar meestal van.

“All the way” zelfvoorzienend worden is daarom meestal onhoudbaar. Een bekende case studie is die van de stad München, die vanaf 2006 ambitieus overschakelde naar een zelf ontwikkelde Linux-omgeving, maar omwille van aanslepende compatibiliteitsproblemen en de daarmee gepaard gaande oplopende beheerskosten, in 2017 de stekker uit het programma trok en opnieuw voor een gestandaardiseerde Microsoft-omgeving koos.

In de buurlanden

Duitsland draagt het idee van digitale soevereiniteit dus al langer een warm hart toe. De Duitse Open Source Business Alliance zet de term zelfs in hun slogan. De ervaring van München evolueerde naar het huidige Open Source Programme Office van de stad. Het Duitse federale niveau moedigt technische onafhankelijkheid ook aan, met onder andere:

• Eigen projecten zoals Sovereign Cloud Stack (lijkt momenteel in transformatie na afloop financiering),
• Het Sovereign Tech Fund, dat financiering voorziet om kritische open-source componenten te onderhouden,
• Het Zentrum Digitale Souveränität (ZenDis), dat overheden ondersteunt bij de afbouw van technologische afhankelijkheden.

Die laatste investeert ook met succes in 2 eigen projecten:

• Het platform OpenCode waar overheidsdiensten hun code kunnen publiceren en delen met anderen,
• De administratieve werkomgeving OpenDesk , die ook typische enterprise-opties omvat zoals Single Sign-on en integraties tussen meetings, chats, kalender, en email.

Frankrijk zit evenmin stil. Verschillende initiatieven voor digitale soevereiniteit worden bij onze zuiderburen getrokken door DINUM, de centrale interministeriële dienst voor digitalisering. Met code.gouv.fr hebben zij ook hun eigen code repository. Daarnaast ontwikkelen ze zelf proactief nieuwe toepassingen in een eigen incubator. Dat resulteerde onder andere in La Suite Numérique, een enterprise-level kantoorsuite die functionaliteiten zoals videochat, webinars, en file transfer aanbiedt, en nu wordt uitgebreid met tekstverwerkers en spreadsheets. Frankrijk zet eveneens in op een maximaal onafhankelijke cloud-strategie, en minstens zo belangrijk, werken ze aan motivatie en kennis bij hun overheidsmedewerkers via de Blue Hats community. Vanuit het bedrijfsleven zet CNLL zich in voor digitale soevereiniteit.

Opvallend aan zowel het Duitse OpenDesk als het Franse La Suite Numérique, is dat beide ook beschikbaar zijn in het Engels. Zelfs in overheidscontext is dus ondertussen het bewustzijn gegroeid dat open-source initiatieven betere slaagkansen hebben als men proactief investeert in internationalisering. Nog hoopgevender is dat DINUM en ZenDis concreet zijn beginnen samenwerken. Op het laatste FOSDEM evenement, de jaarlijks weerkerende hoogmis voor open-source developers in Brussel, stonden overheidssamenwerkingen in de kijker en presenteerden ze een tesamen ontwikkelde notitie-app.

Deze Duits-Franse tandem is een veelbelovend teken dat, als het gaat over het bevorderen van digitale soevereiniteit, de wil alleszins bestaat om Europese krachten wat te bundelen. Er is alvast bekend dat Nederland wil aansluiten bij hun samenwerking. Daar leeft de maatschappelijke discussie immers ook, tot in de Tweede Kamer, met debatten over clouddiensten of DNS. Het onderzoeksinstituut TNO publiceerde er een lijvig rapport over digitale soevereiniteit, de universiteiten agenderen het, en ook het bedrijfsleven besteedt er aandacht aan. Op alle bestuursniveaus ligt digitale soevereiniteit er op tafel.

De rol van Europa

De EU heeft een evident strategisch belang bij (digitale) soevereiniteit. Centrale elementen hierin zijn de recente Digital Markets Act (DMA) en Digital Services Act (DSA). Beide wetgevende kaders hebben tot doel om de macht van buitenlandse technologiereuzen te beperken en het speelveld voor Europese bedrijven gelijkwaardiger en transparanter te maken. Hiermee wil Europa haar strategische autonomie versterken door duidelijke regels te stellen rondom data- en platformbeheer, waardoor Europese lidstaten minder kwetsbaar worden voor externe afhankelijkheden. De Cybersecurity Act en de NIS2-richtlijn moeten erover waken dat daarbij niet aan veiligheid en betrouwbaarheid wordt ingeboet.

Ze onderneemt daarnaast tal van relevante initiatieven, maar die komen niet allemaal even vlot van de grond. De Europese versnippering is een oud zeer. Kleine projecten blijven vaak klein, en eens de financiering afloopt, verworden ze tot abandonware. Zo is het onvoorspelbaar of het net gestarte European Open Source Academy het einde van haar financieringsronde in 2027 zal overleven. Grootschalige consortia kennen dan weer heel wat problemen met coördinatie en sturing. Het GAIA-X project heeft zo enigszins de reputatie gekregen als een verhaal van meer memo’s dan demo’s, wat maakt dat ook nieuwe projecten zoals OpenEuroLLM met enige scepsis onthaald worden. De uitrol van de Europese Data Spaces in verschillende domeinen moet data-autonomie bevorderen. Voor gezondheid (EHDS) wordt deze verplicht, wat misschien voor nieuw momentum kan zorgen. Maar dat is niet genoeg om de bezorgdheden weg te nemen: het lijvige EuroStack rapport van de Bertelsmann Stiftung stelt de EU zelfs op een dienblaadje een ambitieuzere visie voor.

Onder de paraplu van Interoperable Europe vinden we naast Public Sector Techwatch en GovTech Connect ook OSOR, het Open Source Observatory and Repository, terug. Zij monitoren ondertussen al meer dan 15 jaar het gebruik van open-source in Europese overheidsadministraties, en moedigen samenwerkingsverbanden en hergebruik aan. Met de recent gelanceerde Open Source Solutions Catalogue moet het gemakkelijker worden voor landen om elkaars oplossingen te hergebruiken. Daarnaast publiceren ze rapporten, case studies, nationale catalogi (waarin we ict-reuse.be terugvinden) en een nieuwsbrief. Overheden die zelf een Open Source Program Office (OSPO) willen oprichten om actief bij te dragen aan open-source projecten, net zoals de EU er een heeft, vinden bij hen steun. Nederland is alvast overtuigd. Als Belgische overheden zichtbaar willen bijdragen aan digitale soevereiniteit, ligt hier nog een uitgelezen kans.

Conclusie

Digitale soevereiniteit is meer dan een technische keuze. Het is een continue strategie om agency terug te winnen in een sterk geïnterconnecteerde digitale wereld waarvan fundamentele bouwblokken plots kunnen verschuiven. We willen niet alleen technologie consumeren, maar deze ook actief vormgeven, begrijpen en controleren. Zo beperken we externe afhankelijkheden en de risico’s die daarmee gepaard gaan. Europees denken en samenwerken biedt daarbij opportuniteiten voor synergieën.

Technologische autonomie vereist een gezond technologisch ecosysteem. Permanente aandacht voor menselijk kapitaal en kennisopbouw zijn een must. Om dat te doen slagen op een duurzame manier, verdienen ondersteunende initiatieven de nodige middelen:

• Proactief technologische alternatieven ontwikkelen, anticiperend op de vraag,
• Participeren in kennisuitwisseling, evenementen en netwerken, met vakgenoten, kennisinstellingen, buurlanden, EU, …
• Actief meewerken aan, of investeren in, bestaande open-source oplossingen die je zelf hergebruikt,
• Communities uitbouwen rondom eigen projecten,
• Investeren in aantrekkelijke vormgeving en gebruiksgemak van de eigen oplossingen,
• Eigen oplossingen inzetbaar maken buiten de eigen muren: publiceren als open-source, integreren in catalogi, een Engelse vertaling en documentatie toevoegen,
• Werken aan naambekendheid: websites, promotie, marketing, vakbeurzen, (social) media, …
• …

Wie interesse heeft om dit thema verder op te volgen, kan de in dit artikel vermelde organisaties en initiatieven volgen op sociale media of via hun nieuwsbrieven. Voor een deep dive is het bovenvermelde EuroStack rapport interessant. Om alternatieven te zoeken voor afhankelijkheden in je eigen projecten, zijn european-alternatives.eu, euro-stack.com, of alternativeto.net goede startpunten. Tot slot: digitale soevereiniteit is een team effort, voel je daarom vrij om andere bronnen, projecten, of interessante links te delen in de commentaren hieronder!

______________________

Dit is een ingezonden bijdrage van Joachim Ganseman, IT consultant bij Smals Research. Dit artikel werd geschreven in eigen naam en neemt geen standpunt in namens Smals.

Met de opkomst en toenemende complexiteit van IT-toepassingen is het documenteren van data en programma’s meer dan ooit van vitaal belang voor een goed ‘data governance‘, ongeacht de betrokken sector.

Begin jaren 2000 hebben we meegewerkt aan het opzetten van de glossaria van de sociale zekerheid en hebben we de verdere ontwikkeling ervan gevolgd. De concepten in deze blogpost zijn ons dus niet onbekend, aangezien sommige kenmerken sinds de jaren 2000 niet zijn veranderd.

Na het definiëren van het concept van een “data catalog” of “metadata management systeem”, schetsen we de organisatie, belangrijkste functies [1] en best practices. Ter afsluiting stellen we een reeks generaliseerbare methodologische aanbevelingen op.

Metadata Management Systeem of “Data Catalog”: definitie en beheerstrategie

“Meta-informatie” wordt vaak gedefinieerd als “informatie over informatie”. We hanteren hier de volgende definitie: een metadata management systeem is een geautomatiseerd documentair systeem ontworpen om een set informatie of data te beschrijven, te interpreteren en zo het beheer ervan te vergemakkelijken. Dergelijke systemen gebruiken is van strategisch belang wanneer informatie een instrument is om actie op de realiteit te ondernemen [2].

Een metadata management systeem behoort tot de managementstrategie. De bijbehorende kosten komen voort uit analyse, ontwerp, ontwikkeling of aanschaf van software en onderhoud. De verwachte winsten zijn een betere interpretatie van de informatie, gemakkelijker hergebruik van reeds bestaande toepassingen, een grotere geloofwaardigheid van het systeem en lagere beheerkosten (correcties achteraf in de database, vergoeding van schade veroorzaakt door de verspreiding van onjuiste gegevens, etc.)[3].

Metadata Management Systeem of “Data Catalog”: functies

Data Ingestion, Rollen, IAM, beheer van de regels

We presenteren achtereenvolgens de volgende functionaliteiten: rollen en impact, beheer van meertalige velden, versiebeheer, implementatie van overervingsmechanismen, toepassing van het WOPM-concept (Write Once Publish Many), standaarden, Graph Databases, publicatie als een REST API, multibasezoeksysteem, deployment van een workflow voor documentvalidatie (eventueel inclusief gesuperviseerde Machine Learning in de Data Catalogs) en een paar woorden over de software.

Een Data Catalog moet automatisch gevoed of vergeleken worden met andere gerelateerde systemen: dit staat bekend als “data ingestion”. Zo werden in het begin van de jaren 2000 de glossaria van de sociale zekerheid gecreëerd, waarin de uitwisseling van informatie tussen de RSZ en de dienstverleners enerzijds en de werkgevers of erkende sociale secretariaten anderzijds werd gedocumenteerd. Deze glossaria werden gevoed met de eerste basisinformatie, die toen gestructureerd werd in Word, met behulp van een PERL-programma. Er bestaan andere, modernere methoden hiervoor, afhankelijk van de context.

Een Data Catalog is bedoeld voor IT- en business managers die verantwoordelijk zijn voor het beheer van databases, bijvoorbeeld via een portaal dat toegankelijk is voor burgers voor het elektronisch indienen van aangiften bij de overheid. Het doel is dat iedereen op een gemeenschappelijke basis werkt. Hierbij worden toegangsrechten beheerd via een IAM.

Het doel van dit metadata management systeem is om de daaropvolgende procedures voor het invoeren, vertalen en valideren van documentatie gedeeltelijk te automatiseren, de integriteit ervan te versterken en de versies ervan te beheren in overeenstemming met juridische wijzigingen. De bedoeling is om “de kennis en de processen die deze genereren” te modelleren. Het woordenboek bevat daarom zowel beschrijvende informatie (bijvoorbeeld het definitiedomein van een veld) als functionele informatie (bijvoorbeeld de formele specificatie van controles om inkomende aangiften te testen). Bovendien kunnen de schema’s van uitgewisselde berichten tussen burgers en de overheid of andere partijen worden gegenereerd vanuit de Data Catalog.

Beheer van meertalige velden

Technische documentatie moet verdeeld worden in de verschillende nationale talen. Hetzelfde geldt in elke supranationale context. Gecontroleerde meertalige tabellen (gevalideerd door vertalers, juristen en IT) maken het mogelijk om bij de inbreng van de definities de informatie te integreren in één taal en de equivalenten in de andere talen te bekomen. Dit alles kan indien nodig op specifiek niveau worden ingevuld (zie hieronder: overerving). Op die manier wordt de manuele werkbelasting geminimaliseerd, wordt het inbrengproces versneld en wordt de coherentie van het geheel versterkt.

Versiebeheer

Versiebeheer is fundamenteel op administratief gebied [3]. De wetgeving wijzigt vaak en alle opeenvolgende versies moeten ten minste gedurende de verjaringstermijn worden bewaard (bij het behandelen van achterstallige betalingen is het bijvoorbeeld essentieel om eerdere definities uit de database te kunnen halen, aangezien geregistreerde verklaringen de wettelijke status van “bewijskracht” hebben, d.w.z. dat ze als “bewijs” kunnen worden gebruikt in een rechtsprocedure). Het is daarom cruciaal om precies vast te stellen welke wijzigingen er in elke nieuwe versie zijn aangebracht ten opzichte van de vorige. Deze “delta” wordt overigens verspreid onder het standaardformaat, zodanig dat de wijzigingen semigestructureerd geïntegreerd kunnen worden in de toepassingen die de databases omkaderen. Elk item dat de beschrijving van gegevens voor een bepaalde versie specificeert, verwijst naar het corresponderende bestand (in de door de gebruiker gekozen taal) met details van de gewijzigde velden ten opzichte van de direct voorgaande versie, inclusief de geschiedenis van verwijderde documenten.

Validatieworkflow (en supervised ML)

Vanwege de juridische, sociale en financiële belangen die op het spel staan, moet elke nieuwe versie worden gevalideerd door de betrokken IT- en juridische experts. Om deze validatie te structureren, begeleidt een workflowsysteem de implementatie van de Data Catalog. Dit maakt deel uit van een jaarlijks updateschema waarin de perioden voor bijwerking, validatie, acceptatie en productie nauwkeurig zijn vastgelegd. De workflow wordt centraal “gestuurd” door een team dat zich aan deze taak wijdt en ontplooit zich op gedecentraliseerde wijze, zoals bijvoorbeeld in het kader van het extranet van de sociale zekerheid (Figuur 1). Telkens een nieuwe versie aangemaakt wordt, wordt de historiek bijgehouden van de uitwisselingen tussen de verschillende verantwoordelijken, zodat men het interpretatieproces kan opvolgen. Aan de hand van een view kunnen de beheerders het aantal “fiats” volgen dat vereist is voor de publicatie van een nieuwe versie. Dit biedt een overzicht van verschillende onderling verbonden Data Catalogs.

Figuur 1. Documentatie over de glossaria van de sociale zekerheid: IT- en bedrijfsworkflow

Daarnaast zijn er nu ook gecontroleerde supervised ML-functies met menselijke tussenkomst om metadatawijzigingen te valideren op basis van wijzigingen aan de data (op voorwaarde dat deze eerst zijn gevalideerd door de bedrijfsregels van de corresponderende databases, om te voorkomen dat metadata worden gegenereerd op basis van onjuiste gegevens).

Overerving en hergebruik in een meertalige context

Het metadata management systeem kan ontworpen zijn om enkele tientallen administratieve databases te documenteren met een groot aantal gemeenschappelijke velden, waarvan sommige kenmerken identiek zijn (bijvoorbeeld formaat) en andere verschillend (bijvoorbeeld verplichte of optionele aard van een veld). Een overervingsmechanisme moet daarom geïntegreerd worden.

Overerving (Figuur 2) wordt gedefinieerd als de relatie tussen een generieke klasse A (die we hier “stereotype” noemen of algemeen vocabulaire dat weinig evolueert) en al zijn instanties {a₁, a₂, …a_n}, waarbij de properties (p₁, p₂, …p_k) van klasse A een subset zijn van de properties van elk object dat uit klasse A wordt geïnstantieerd. Tijdens de instantiëring kan deze subset van generieke eigenschappen worden aangevuld met een andere subset van eigenschappen die specifiek zijn voor elke instantie (p_1+pa1, p_2+pa2, …p_k+pan). Dit mechanisme kan worden toegepast op een willekeurig aantal “meta”-niveaus.

Figuur 2. Documentatie over de glossaria van de sociale zekerheid: overervingsprincipe

De waarden van de generieke properties (“naam”’, “definitiedomein”, “beschrijving”, “type”, “lengte”) van het stereotype “rekeningnummer” worden dus opgeslagen in een “gecontroleerde” tabel van generiek gestructureerde data, vooraf vertaald en gevalideerd door de juristen en IT.

De generieke en specifieke waarden worden vervolgens samengevoegd tot een semigestructureerd veld. Deze functionaliteiten bieden voordelen in termen van updatetijd (elke generieke waarde moet slechts eenmaal gecodeerd worden)  en in termen van consistentie. Het systeem garandeert dat gemeenschappelijke data dezelfde waarden krijgen en voorkomt menselijke fouten die inherent zijn aan handmatige invoering.

WOPM (Write Once Publish Many), Standaarden, Graph Database en publicatie in de vorm van REST API

De toepassing omvat gestructureerde lijsten (postcodes, activiteitencategorieën, …) die in de praktijk verspreid moeten worden voor documentaire doeleinden (in de geest van een metadata management systeem) maar ook met het oog op het testen van de aangiften gestuurd door de burgers en die opgeslagen zijn in de databases. Om aan beide te voldoen, moet de toepassing worden ontworpen volgens het WOPM-concept (“Write Once Publish Many”), zodat dezelfde gestructureerde tabel (bijvoorbeeld een lijst met postcodes) automatisch in verschillende formaten wordt gegenereerd: voor mensen leesbare en voor machines leesbare formaten. Dezelfde bron kan zo gebruikt worden binnen onderling afhankelijke toepassingen.

Vandaag bestaan er, met de komst van het “Semantische Web”, talrijke standaarden op dit gebied. Sommige bieden generieke syntaxis voor het gebruik van metadata, zoals DCAT, een EU-aanbeveling. Op technisch niveau kunnen deze standaarden worden aangevuld met XML of JSON, die vooral handig zijn voor het samenvoegen van tabellen (Figuur 4), en andere formaten.

Een graph database (Figuur 3) brengt de status van relaties tussen verschillende datacatalogi in beeld, en het deel van de metadata dat al dan niet compleet is. Afhankelijk van hoe volledig ze zijn, kun je beslissen of je een datacatalogus wel of niet publiceert in de vorm van een REST API binnen een instelling (Figuur 3).

Figuur 3. Gebruik van een graph database om de volledigheid te controleren van een Data Catalog – Bron: Collibra website

De Data Catalog kan worden gepubliceerd in de vorm van een REST API en zelf andere REST API’s hosten of aansluiten op reeds bestaande commerciële software. Bepaalde standaarden, zoals de hierboven genoemde JSON (afbeelding 4), vergemakkelijken deze koppelingen aan (1).

Figuur 4. Voorbeeld van het koppelen van twee metadatasystemen via JSON (Bron zie opmerking 3)

Multibase zoeksysteem

Een “multibase” zoeksysteem (Figuur 5) moet worden opgezet, waarmee “full text” kan worden gezocht in het geïntegreerde documentensysteem op basis van specifieke parameters met behulp van Booleaanse logica, evenals sorteer- en filtersystemen. De output van de zoekfunctie kan in verschillende formaten worden gepresenteerd, afhankelijk van het beoogde gebruik (menselijk leesbaar of machinaal leesbaar).

Figuur 5. Voorbeeld van multibase, multilingual en multifield searches met opties (bron: social security glossaries)

Voortdurende beoordeling en onderhoud van de kwaliteit van gegevens en metadata

Het handhaven van de kwaliteit van data en metadata is van fundamenteel belang. Er zijn twee complementaire benaderingen. We kunnen werken met een complete data quality tool om problemen aan te pakken die al aanwezig zijn in de databases, inclusief profilering-, standaardiserings- en matchingfuncties (curatieve aanpak). Om te voorkomen dat dezelfde fouten zich ad infinitum bij de bron herhalen, kunnen we gebruik maken van backtracking en ATMS (preventieve aanpak), bedacht bij Smals Research om de oorzaken van kwaliteitsproblemen bij de bron op te lossen (zie ReUse-catalogus). De kwaliteit van data en de bijbehorende metadata continu verbeteren is cruciaal (zie het competentiecentrum Data Quality’ op de Smals-website, inclusief REST API’s uit de Smals Software ReUse-catalogus) (5).

Software

Op softwareniveau bestaan er buiten “home made”-oplossingen zoals de glossaria van de sociale zekerheid, waarnaar verschillende figuren van deze blogpost verwijzen, ook “open source” development environments zoals Egeria die ontwikkelingen vereisen, of commerciële instrumenten zoals Collibra, Altan, Infosphere, …

Metadata Management Systeem: methodologische aanbevelingen  

De metadata management systemen hebben drie potentiële hinderpalen. De eerste hangt samen met het feit dat deze systemen oneindig uitbreidbaar zijn. Dit is voornamelijk het geval wanneer in te vullen velden “vrij” zijn, waarbij de natuurlijke taal zijn eigen metataal is. Dit brengt aanzienlijke beheerkosten met zich mee wanneer er een groot aantal manuele updates zijn. De tweede valkuil bestaat erin dat de metadata zelf foutief en onzeker kunnen zijn: wanneer ze contextueel zijn, kan de validatie ervan niet aan strikte integriteitsbeperkingen worden onderworpen. De derde hinderpaal hangt samen met het tijdsverschil tussen de bijwerking van een data en van de bijbehorende metadata, waarbij deze laatste, vooral als het voorkomt onder tekstuele vorm, meestal pas aangemaakt wordt op het einde van een min of meer lange analysefase.

Zo roepen verschillende auteurs de onlosmakelijke praktische problemen op die het “misbruik” van metadata met zich meebrengt in een doortastende communicatie “The Metadata Myth” [4]. Wat betreft geospatiale databases die worden beheerd door het Bureau of Census en de National Aeronautics and Space Administration (NASA) resulteerde de implementatie van een federaal metadatasysteem waarvoor elk nieuw record de integratie van ongeveer 300 metadata vereiste, in de volgende problemen: buitensporige kosten in termen van personeel en middelen, zware updates, esoterische documentatie en, ten slotte, een aanzienlijke vermindering van de data-uitwisseling. NASA heeft dit systeem echter niet verlaten, maar wel vereenvoudigd en geherstructureerd.

Op basis van onze ervaring op dit gebied stellen wij de volgende vijf aanbevelingen voor:

• Identificeer een minimumset van verplichte metadata.
• Geef voorkeur aan automatisch gegenereerde meta-informatie (of bijvoorbeeld op basis van lijsten van gecontroleerde waarden), deze informaties zijn immers minder “duur” in termen van updates en zijn daarbij ook betrouwbaarder (cfr. supervised ML onder de hierboven aangegeven voorwaarden).
• Creëer verschillende niveaus van metadata, aangepast aan verschillende toepassingen (generieke en specifieke metadata, bijvoorbeeld).
• Leg directe verbanden tussen gedocumenteerde toepassingen en de bijbehorende metagegevens (principe van integriteit en consistentie).
• Pas KPI’s toe gedurende de gehele levenscyclus van de Data Catalog om verschillende belangrijke statistieken te monitoren, zoals het raadplegingspercentage voor verschillende delen van de Data Catalog (6).

Naast de toepassing die in dit artikel wordt gepresenteerd, zijn deze aanbevelingen van toepassing op elke empirische database waarvan de interpretatie strategisch is, als instrument om te handelen op de werkelijkheid, en dus op elke “Data Catatog”.

Deze blogpost werd geschreven door Isabelle Boydens, Data Quality Expert bij Smals Research. Dit artikel is geschreven onder haar eigen naam en weerspiegelt op geen enkele wijze de standpunten van Smals.

[2] “In mei 1999, tijdens haar interventie in Kosovo, bombardeerde de NAVO per ongeluk de Chinese ambassade in Belgrado: de cartografische databanken die toen gebruikt werden om raketten te leiden, gaven een verouderde en dus onbruikbare kaart van de stad weer” BOYDENS I., L’océan des données et le canal des normes.”  In CARRIEU-COSTA M.-J., BRYDEN A. en COUVEINHES P. eds, Les Annales des Mines, Reeks “Responsabilité et Environnement” (themanummer: “La normalisation : principes, histoire, évolutions et perspectives”), Paris, n° 67, juli 2012, p. 22-29 (link naar het artikel – Inhoud van nummer 67 van Annales des Mines).

Avec l’émergence et la complexité croissantes des applications informatiques, la documentation des données et des programmes est plus que jamais vitale, pour une bonne « data governance » quel que soit le secteur d’activité concerné.

Au seuil des années 2000, nous avons contribué à la mise en place des glossaires de la sécurité sociale et avons suivi leur développement par la suite. Pour cette raison, les concepts de cet article de blog nous sont familiers car certaines fonctionnalités n’ont pas changé depuis les années 2000.

Après une définition du concept de « Data Catalog » ou « système de méta-information ». nous en présentons dans les grandes lignes l’organisation, les fonctions principales [1] et les bonnes pratiques. En conclusion, nous dégageons un ensemble de recommandations méthodologiques généralisables.

Les systèmes de méta-information ou « Data Catalog » : définition et stratégie de gestion

« Méta-information » est souvent défini comme « information sur l’information ». Nous retenons ici la définition suivante : un système de méta-information est un système documentaire automatisé destiné à décrire un ensemble d’informations ou de données et ce faisant, à les interpréter en vue d’en faciliter la gestion. Le recours à de tels systèmes est stratégique lorsque l’information est un instrument d’action sur le réel[2].

La conception d’un système de méta-information s’inscrit dans le cadre d’une stratégie de gestion. Les coûts correspondants émanent des opérations d’analyse, de conception, de développement ou d’acquisition de software et de maintenance. Les bénéfices escomptés tiennent à une meilleure interprétation de l’information, à une réutilisation plus aisée des applications préexistantes, à une crédibilité accrue du système et à une diminution des coûts de gestion (corrections a posteriori de la base de données, réparation des préjudices dus à la diffusion de données incorrectes, …)[3].

Les systèmes de méta-information ou « Data Catalog » : fonctions

Data Ingestion, Rôles, IAM, gestion des règles

Nous présentons successivement les fonctionnalités suivantes : rôles et impact, gestion de champs multilingues, gestion des versions, mise en place de mécanismes d’héritage, application du concept de WOPM (Write Once Publish Many), standards, Graph Databases, publication en tant que REST API, système de recherche multibases, déploiement d’un worfklow de validation documentaire (incluant éventuellement du Machine Learning supervisé dans les Data Catalogs) et quelques mots sur les softwares.

Un Data Catalog doit être alimenté ou croisé automatiquement avec d’autres systèmes connexes : on appelle cela “data ingestion”. Ainsi, quand les glossaires de la sécurité sociale documentant les échanges d’information entre l’ONSS et les organismes prestataires, d’une part et les employeurs ou secrétariats sociaux agréés, d’autre part, créés au seuil des années 2000, l’alimentation des premières informations de base alors structurées en Word, fut réalisée via un programme PERL. D’autres méthodes plus modernes existent à cette fin en fonction du contexte.

Un Data Catalog s’adresse à la fois aux informaticiens et responsables business en charge de la gestion des bases de données, par exemple via un portail  accessible aux citoyens en charge de l’envoi des déclarations électroniques à l’administration, l’objectif étant que tous travaillent sur une base commune. Il s’agit que les droits d’accès soient gérés via un IAM.

Ce système de méta-information vise à automatiser partiellement les procédures ultérieures de saisie, de traduction et de validation de la documentation, à en renforcer l’intégrité et à en gérer les versions au fil des modifications législatives. Il s’agit de modéliser la connaissance et les processus qui l’engendrent : ainsi, le dictionnaire inclut à la fois des informations descriptives (par exemple, le domaine de définition d’un champ) et fonctionnelles (par exemple, la spécification formelle des contrôles destinés à tester les déclarations entrantes). Par ailleurs, les schémas des messages échangés entre les citoyens et l’administration ou toute autre partie peuvent être générés à partir du Data Catalog.

Gestion de champs multilingues

La documentation technique doit être diffusée dans les différentes langues nationales. Il en est de même dans tout contexte supranational. Des tables contrôlées multilingues (validées par les traducteurs, les juristes et l’IT) permettent, lors de la saisie des définitions, d’intégrer l’information dans une langue et d’obtenir ses contreparties dans les autres langues. L’esnsemble pourra être complété au niveau spécifique si nécessaire (voir plus loin : héritage). Ceci permet de minimiser la charge de travail manuel, d’accélérer le processus de saisie et de renforcer la cohérence de l’ensemble.

Gestion des versions

La gestion des versions est fondamentale dans le domaine  administratif[3]. En effet, la législation évolue fréquemment et toutes ses versions successives doivent être conservées au moins durant la période de prescription (par exemple, lorsqu’il s’agit de traiter des arriérés, il est fondamental de pouvoir retrouver les définitions antérieures de la base de données, les déclarations enregistrées ayant un statut légal de « force probante », c’est-à-dire qu’elles peuvent faire office de « preuve » lors d’un litige devant les tribunaux). Il est dès lors crucial d’identifier précisément les modifications apportées à chaque nouvelle version par rapport à la précédente. Ce « delta » est par ailleurs diffusé sous format standard, de telle sorte que les modifications puissent être intégrées de façon semi-structurée dans les applicatifs encadrant les bases de données. Chaque item spécifiant la description d’une donnée pour une version considérée renvoie à la fiche correspondante (dans la langue choisie par l’utilisateur) avec la mention des champs modifiés par rapport à la version immédiatement antérieure, en ce compris l’historique des documents supprimés.

Workflow de validation (et ML supervisé)

En raison des enjeux légaux, sociaux et financiers correspondants, chaque nouvelle version doit être validée par les informaticiens et les juristes concernés par celle-ci. En vue de structurer cette validation, un système de workflow guide le déploiement du data catalog. Celui-ci s’inscrit dans le cadre d’un planning annuel de mise à jour, spécifiant de façon rigoureuse les périodes de mise à jour, de validation, de mise en acceptation et de mise en production. Le workflow est « piloté » de façon centralisée par une équipe dédiée à cette tâche et se déploie sur un mode décentralisé dans le cadre de l’extranet de la sécurité sociale, par exemple (Figure 1). Lors de la création de chaque nouvelle version, l’historique des échanges entre les différents responsables est conservé, de façon à garder un suivi du processus d’interprétation. Une vue permet aux gestionnaires de suivre le nombre de « fiats » requis pour la publication d’une nouvelle version. Ceci permet d’avoir une vue sur différents data catalogs interconnectés.

Figure 1. Documentation des glossaires de la sécurité sociale : workflow IT et Business

A cela s’ajoutent actuellement des fonctions de ML supervisé avec intervention humaine pour valider les modifications de méta-données à partir des modifications de data (à condition que celles-ci aient préalablement été validées par les business rules des bases de données correspondantes pour éviter de générer une méta-donnée à partir d’une donnée incorrecte).

Héritage et réutilisation dans un contexte multilingue

Le système de méta-information est éventuellement destiné documenter plusieurs dizaines de bases de données administratives répertoriant de nombreux champs communs dont certaines caractéristiques sont identiques (format, par exemple) et d’autres, distinctes (caractère obligatoire ou facultatif d’un champ, par exemple). Un mécanisme d’héritage doit dès lors être mis en place.

L’héritage (Figure 2) se définit comme la relation entre une classe A générique (que nous appelons ici « stéréotype » ou vocabulaire commun peu évolutif) et l’ensemble de ses instances {a₁, a₂, … a_n}, où les propriétés (p₁, p₂, …p_k) de la classe A constituent un sous-ensemble des propriétés de chaque objet instantié à partir de la classe A. Lors de l’instantiation, ce sous-ensemble de propriétés génériques peut être complété par un autre sous-ensemble de propriétés spécifiques à chaque instance (p_1+pa1, p_2+pa2, …p_k+pan). Ce mécanisme est applicable à un nombre arbitraire de niveaux « méta ».

Figure 2. Documentation des glossaires de la sécurité sociale : principe de l’héritage

Les valeurs des propriétés génériques (« nom », « domaine de définition », « description », « type », « longueur ») du stéréotype « numéro de compte » sont ainsi stockées dans une table « contrôlée » de données structurées génériques prétraduites et prévalidées par les juristes et l’IT.

Les valeurs génériques et spécifiques sont ainsi concaténées en un champ semi-structuré. Ces fonctionnalités apportent des avantages en terme de temps de mise à jour (chaque valeur générique ne devant être encodée qu’une seule fois) et en terme de cohérence. Le système permet d’assurer que les données communes reçoivent les mêmes valeurs et d’éviter les erreurs humaines inhérentes à l’encodage manuel.

WOPM (Write Once Publish Many), Standards, Graph Database et publication sous forme de REST API

L’application inclut des listes structurées (codes postaux, catégories d’activité, …) qui, dans la pratique, doivent être diffusées à des fins documentaires (dans l’esprit d’un “système de méta-information”) mais aussi en vue de tester les déclarations envoyées par les citoyens et stockées dans les bases de données. Afin de rencontrer les deux fonctions, l’application doit être conçue dans l’optique du concept WOPM (« Write Once Publish Many ») de façon à générer automatiquement une même table structurée (liste de codes postaux, par exemple) sous différents formats : formats lisibles par l’humain et par la machine. La même source peut ainsi être utilisée au sein d’applications interdépendantes.

A l’heure actuelle, dans la mouvance du « Web sémantique », les normes en la matière sont devenues nombreuses. Les unes offrent des syntaxes génériques permettant le déploiement de méta-données, tel que DCAT, recommandation de l’UE. A ces normes, sur le plan technique, peuvent s’ajouter XML ou JSON, particulièrement utile pour la fusion de tables (Figure 4) et d’autres formats encore.

Une graph database (Figure 3) permet de visualiser l’état des relation entre différents « Data Catalogs » et pour ceux-ci, la part des méta-données complétées ou pas. En fonction de leur état plus ou moins complet, on peut décider de la publication d’un “data catalog” sous forme de REST API au sein d’une institution (Figure 3).

Figure 3. intérêt d’une graph database pour suivre la complétude d’un data Catalog Source : Collibra website

Le Data Catalog peut être publié sous forme de REST API et accueillir lui-même d’autres REST API ou « plugger » des logiciels commerciaux préexistants, certains standards comme JSON cité plus haut (Figure 4) favorisent ces liens (1).

Figure 4. Exemple de mapping de 2 systèmes de méta-données via JSON (Source voir note 3)

Système de recherche multibases

Un outil de recherche «multibase » (Figure 5) doit être mis en place, permettant une recherche « full text » à travers le système documentaire intégré sur base de paramètres spécifiques avec recours à la logique booléenne de même que des systèmes de tri et de filtrage. L’output de l’outil de recherche peut se présenter sous différents formats en fonction des usages poursuivis (lisible par l’homme ou par la machine).

Figure 5. Exemple de recherches multibases, multilingues et multichamps avec options (source : glossaires de la sécurité sociale)

Evaluation continue et maintien de la qualité des données et des méta-données

Un maintien de la qualité des données et des méta-données est fondamental. Deux approches complémentaires existent. On peut travailler via un data quality tool complet afin de traiter les problèmes déjà présents dans les bases de données incluant les fonctions de profiling, standardization et matching (approche curative). On peut pour que les mêmes erreurs ne reviennent pas “ad infinitum” à la source, procéder via back tracking et ATMS (approche préventive), inventée au sein de Smals Research pour résoudre à la source les causes des problèmes de qualité (voir catalogue Reuse). Améliorer de manière continue la qualité des données et des méta-données correspondantes est crucial (voir le centre de compétence “data quality” sur le web site de Smals incluant des REST API sur le catalogue Software ReUse de Smals) (5).

Softwares

Au niveau software, outre des solutions « home made », comme les glossaires de la sécurité sociale auxquels plusieurs images de cet article de blog réfèrent, il existe des environnements de développement « open source » comme Egeria demandant du développement, ou bien des outils commerciaux, comme Collibra, Altan, Infosphere, …

Les systèmes de méta-information : recommandations méthodologiques  

Les systèmes de méta-information comportent potentiellement trois écueils. Le premier est lié à ce que ces systèmes sont extensibles à l’infini., surtout lorsque les champs à compléter sont « libres », le langage naturel étant son propre méta-langage. Ceci implique des coûts importants en termes de gestion, lorsque les mises à jour manuelles sont nombreuses. Le second écueil tient à ce que les méta-données peuvent être elles-mêmes erronées et incertaines : lorsqu’elles sont d’ordre contextuel, leur validation ne peut faire l’objet de contraintes d’intégrité rigoureuses. Le troisième écueil tient au décalage temporel entre la mise à jour d’une donnée et de la méta-donnée correspondante, cette dernière, surtout lorsqu’elle se présente sous une forme textuelle, n’étant généralement créée qu’au terme d’une phase d’analyse.

Ainsi, dans une communication retentissante, “The Metadata Myth…”[4], plusieurs auteurs évoquent les inextricables difficultés pratiques que soulève “l’usage abusif” des méta-données. Dans le domaine des bases de données géospatiales exploitées par le Bureau of census et la National Aeronautics and Space Administration (NASA), la mise en place d’un système de méta-information fédéral pour lequel chaque nouvel enregistrement nécessitait l’intégration d‘environ 300 méta-données a entraîné les avatars suivants : coûts exorbitants en personnel et en ressources, lourdeur des mises à jour, ésotérisme de la documentation et finalement, réduction considérable de l’échange des données. Cependant, la NASA n’a pas abandonné ce système qui a toutefois fait l’objet d’une simplification et d’une restructuration.

Sur base des expériences en la matière, nous proposons les cinq recommandations suivantes :

• l’identification d’un ensemble minimal de méta-données obligatoires.
• une préférence pour les méta-informations générées automatiquement (ou sur base de listes de valeurs contrôlées par exemple) car ces informations sont moins “coûteuses” en termes de mise à jour et plus fiables (cfr ML supervisé sous les conditions indiquées plus haut).
• la création de plusieurs niveaux de méta-données adaptés en fonction des usages (méta-données génériques et spécifiques, par exemple).
• La mise en place de liens directs entre les applicatifs documentés et les méta-données correspondantes (principe d’intégrité et de cohérence).
• Appliquer tout au long du cycle de vie du Data Catalog des KPI pour monitorer différentes métriques importantes, comme le taux de consultation des différentes parties du Data Catalog (6).

Au delà de l’application présentée dans cet article, ces recommandations s’appliquent à toute base de données empiriques dont l’interprétation est stratégique, en tant qu’instrument d’action sur le réel et donc, à tout « Data Catatog » .

Ce post est une contribution d’Isabelle Boydens, Data Quality Expert chez Smals Research. Cet article est écrit en son nom propre et n’impacte en rien le point de vue de Smals.

[1] O. Olesen-Bagneux, The Entreprise Data Catalog :Improve Data Discovery, Ensure Data Governance, and Enable Innovation. Boston, O’Reilly, 2023.

[2] « En mai 1999, pendant son intervention au Kosovo, l’Otan a bombardé par erreur l’ambassade de Chine à Belgrade : les bases de données cartographiques alors utilisées pour guider les missiles répertoriaient un plan de la ville obsolète et, donc, inadéquat” BOYDENS I., L’océan des données et le canal des normes. In CARRIEU-COSTA M.-J., BRYDEN A. et COUVEINHES P. éds, Les Annales des Mines, Série “Responsabilité et Environnement” (numéro thématique : “La normalisation : principes, histoire, évolutions et perspectives”), Paris, n° 67, juillet 2012, pp. 22-29 (lien vers l’article – sommaire du numéro 67 des Annales des Mines).

[3] Marcus Christie, Suresh Marru, Sudhakar Pamidighantam, Isuru Ranawaka, and Dimuthu Wannipurage. 2023. Airavata Data Catalog: A Multi-tenant Metadata Service for Efficient Data Discovery and Access Control. In Practice and Experience in Advanced Research Computing (PEARC ’23), July 23–27, 2023, Portland, OR, USA. ACM, New York, NY, USA https://doi.org/ 10.1145/3569951.3597572

[4]Foreman T. W., Wiggins H. V., Porter D.L., Metadata Myth : Misunderstanding the Implications of Federal Metadata Standards. Proceedings of the First IEEE Metadata Conference. Maryland : IEEE, 1996 (http://www.llnl.gov/liv_comp/metadata/ieee-md.4-96.html).

[5] BOYDENS I., “Strategic Issues Relating to Data Quality for E-government: Learning from an Approach Adopted in Belgium“. In ASSAR S., BOUGHZALA I. et BOYDENS I., éds., “Practical Studies in E-Government : Best Practices from Around the World”, New York, Springer, 2011, p. 113-130 (chapitre 7). BOYDENS I., HAMITI G. et VAN EECKHOUT R., A service at the heart of database quality. Presentation of an ATMS prototype. In Le Courrier des statistiques, Paris, INSEE, 2023, n°6, 11 p. (publié le 2/10/2023). Lien vers l’article.

[6] Asmae Boufassil; Fadwa Bouhafer; Mohamed Cherradi; Anass El Haddadi, Data Catalog: Approaches, Trends, and Future Directions. In 17th International Conference on Signal-Image Technology & Internet-Based Systems (SITIS),   IEEE : 21 March 2024, DOI: 10.1109/SITIS61268.2023.00067

In 2014 publiceerden we een research note over ‘Open Data’ naar aanleiding van de Europese richtlijn PSI (Public Service Information) van 2013 die van toepassing was in 2015 (1). 

Sindsdien verschenen of verschijnen nog steeds andere Europese wetgevingen. Deze nieuwe wetten doen niets af aan wat van toepassing was in 2014 (afgezien van enkele url’s uit de research note van 2014 die niet meer up-to-date zijn) maar verbreden aanzienlijk het toepassingsveld (2) ervan dat we in dit blogartikel gaan voorstellen.

We komen hier niet meer terug op de definitie van ‘open data’, op hun mogelijk betalende aard (minieme kosten van de terbeschikkingstelling van een webservice, bijvoorbeeld in het geval van de KBO en databases van ondernemingen in het algemeen) of op de kwestie van licenties. We verwijzen de lezer hiervoor naar de research note van 2014.

Deze nieuwe reglementeringen zagen het licht in een context waarin nieuwe case study’s als gevolg van de verspreiding van open data tot positief gebruik hebben geleid. Een voorbeeld is het besluit eind 2023 om meteorologische gegevens in Frankrijk openlijk te publiceren om onderzoek en uitwisseling tussen onderzoekers aan te sporen “De instantie zal nieuwe technische mogelijkheden voor API’s invoeren om gratis toegang te krijgen tot haar observatiegegevens, klimatologische gegevens en radargegevens” (zie link hierboven). Zo hebben we sinds 2014 aangetoond in welke mate de terbeschikkingstelling van dynamische meteorologische en geografische gegevens in de VS, samen met het gebruik van social media, ervoor zorgde dat de gevarenzones tijdens een orkaan geïdentificeerd konden worden en hoe getroffen personen in contact kwamen met mensen die hun hulp aanboden (onderdak, etc.). Onderstaand schema toont het ideale circuit van ‘open data’ gaande van de verzameling tot het gebruik van de gegevens.

Verder in dit blogartikel bekijken we:

• vier wetgevingen (een richtlijn en drie verordeningen)
• de uitdaging van kwalitatieve gegevens en de ROI van open data

Richtlijn PSI 2019 (van toepassing in 2021, omgezet in de Belgische wetgeving in december 2023)

Deze richtlijn impliceert de integratie van de volgende nieuwe elementen in het Belgisch koninklijk besluit:

• gratis publicatie en uitwisseling, bovenop de publicaties, van de gegevens die verzameld of geproduceerd worden tijdens onderzoeksactiviteiten en gebruikt als bewijselementen in het onderzoeksproces (variabele modaliteiten naargelang het al dan niet vertrouwelijke karakter van de gegevens, van de toepassing van de GDPR, …)
• aanmoediging van de verspreiding van gegevens met grote toegevoegde waarde, dit wil zeggen waarvan het hergebruik belangrijke voordelen biedt voor de samenleving, het milieu en de economie, met name vanwege hun geschiktheid voor het ontwikkelen van diensten met toegevoegde waarde en van toepassingen, en voor het scheppen van nieuwe, hoogwaardige en fatsoenlijke banen, en vanwege het aantal potentiële begunstigden van op basis van die datasets ontwikkelde diensten of toepassingen met toegevoegde waarde” (PSI 2019). Dit betreft onder andere de volgende toepassingsdomeinen: meteorologie, aardobservatie, milieu,…

• Publicatie van de broncode van de toepassingen van de overheidsdiensten (met uitzonderingen waarmee deze publicatie kan verboden worden, onder andere in het geval van hackrisico, voor algoritmes bedoeld voor de strijd tegen sociale of fiscale fraude, in geval van schending van intellectueel recht, GDPR en ook wat betreft uitwisselingen tussen politieke instellingen en de overheden, enz.)

Data Governance Act (30 mei 2022, van toepassing 9/2023)

In 2014 hebben we voorgesteld de term ‘closed data’ te gebruiken om open data aan te duiden die privé verwerkt worden binnen een gesloten informatiesysteem (bijvoorbeeld in de strijd tegen sociale fraude). In het kader van de DGA zouden we deze benaming kunnen toepassen op de gegevens uit de overheidssector die niet ter beschikking gesteld kunnen worden als open gegevens maar die hergebruikt zouden kunnen worden in een wettelijk kader en onder specifieke voorwaarden. We denken bijvoorbeeld aan medische gegevens waarvan hergebruik kan dienen voor onderzoek, wat in België geleid heeft tot de oprichting van het Health Data Agency (HDA).
Het doel van deze reglementering is om het onderzoek te bevorderen terwijl deze gegevens in een beveiligde context worden verspreid in lijn met het werk van Kristof Verslype over pseudonymisering. Om dit doel te bereiken, moet elke EU-lidstaat één informatiepunt opzetten om informatie over gegevens die door overheidsinstanties worden beheerd, door te geven aan een gemeenschappelijk Europees register (ERPD) en zo het hergebruik ervan te vergemakkelijken.
Op basis daarvan is het ook mogelijk om “data spaces” op te richten. Dit zijn omgevingen waarbinnen gegevens beveiligd en uitgewisseld worden naargelang de behoeften. 

Data Act (13 december 2023, van toepassing 9/2025)

Het doel hiervan is om gegevens te delen, voornamelijk uit de privésector, waarbij toegangs- en gebruiksrechten uitgeklaard worden alsook de uitwisselingen die kunnen plaatsvinden tussen ondernemingen en naar de eindgebruiker. In het geval van een smartwatch bijvoorbeeld zal de gebruiker toegang kunnen vragen tot de gegevens die bijgehouden worden door de ondernemingen die het product verschaffen en deze met derden kunnen delen (bijvoorbeeld voor een herstelling).

Interoperable Europe Act (13 mars 2024, d’application 01/2025)

Deze verordening betreft “de grensoverschrijdende interoperabiliteit van netwerk- en informatiesystemen die worden gebruikt voor het verlenen of beheren van overheidsdiensten in de Unie moet worden versterkt om overheidsdiensten in de Unie in staat te stellen samen te werken en overheidsdiensten over de grenzen heen te laten functioneren”. Dat betekent onder andere een verplichte evaluatie van de interoperabiliteit van de nieuwe diensten vanaf hun ontwerp (“interoperable-by-design public services“), zowel op functioneel als semantisch vlak. Dit impliceert ook de verplichting om broncode te publiceren van de overheidsinstellingen (behalve uitzonderingen, zie hoger). Er blijft een openstaand probleem opdat deze verordening operationele resultaten kan bieden voor het leven van de Europese burgers: de harmonisering van de wetgeving tussen de EU-landen.

De uitdagingen:  kwaliteit evalueren en ROI van de ‘Open data’ 

De kwaliteit van de ‘Open data’

Onderstaand schema toont duidelijk de uitdagingen van ‘Open data’ die in 2014 minder openlijk gespecificeerd werden door de EU-overheden. Verschillende domeinen moeten interageren in verschillende talen en in een internationale context. Het geheel evolueert op een verschillend tempo. Dit kan leiden tot kwaliteitsproblemen van de gegevens (fitness for use) (3) naargelang de min of meer georganiseerde omkadering van de verspreiding van open data. Bijvoorbeeld op het Belgische federaal platform voor open data dat deel uitmaakt van BOSA zijn de leveranciers van open data verantwoordelijk voor de kwaliteit, de beschrijving en de regelmatige updates van deze data. Natuurlijk is feedback vragen aan de gebruikers over de kwaliteit van de gebruikte open data een good practice die vaak voorgesteld wordt (dat is bijvoorbeeld het geval van de KBO in België wat betreft hun open data). Op Europees niveau zijn de leveranciers van gegevens ook verantwoordelijk en ondanks de publicatie van richtlijnen blijft de kwaliteit van het Europees portaal voor open data zeer variabel.

Bron : https://dataeuropa.gitlab.io/data-provider-manual/

Als het gaat over gegevenskwaliteit merken we op dat er verschillende barometers bestaan die onderling landen vergelijken op basis van kwaliteitscriteria: bijvoorbeeld een barometer in 2018 op internationaal niveau (W3C), of de UE Open Data Maturity Assessment, een jaarverslag dat, sinds 2015 en sinds de invoering van het Europees portaal voor open data, een maturiteitsgraad voor elk land toekent op basis van een verzameling ‘vragen-antwoorden’ waaraan een min of meer willekeurige score wordt verbonden. Er wordt eveneens een ‘fact sheet’ uitgewerkt per land (bijvoorbeeld in 2023 voor België).

De ROI van ‘Open Data’

Een andere openstaande vraag betreft  de ROI die soms zeer hoog ligt en zonder uitleg toegewezen wordt aan de Open Data. Hoewel we de kosten die te maken hebben met de verspreiding van kwaliteitsvolle open data wel kunnen inbeelden, vragen we ons af wat de voordelen zijn voor de verspreiders, zoals de federale overheid? Het onderzoek van F. W. Donker van de universiteit van Delft stelt een model voor op basis van concrete maar wel uiteenlopende heterogene waarnemingen.

Dit model stelt een lus met positieve retroactie voor (‘positieve spiraal’); als de overheid gratis en kwaliteitsvolle open data verspreidt, zullen deze gebruikt worden door onderzoekers of ondernemingen die op hun beurt nieuwe activiteiten gaan creëren, die op hun beurt op termijn een bron van belastingen en financiële inkomsten betekenen voor de Staat. Andere voorbeelden worden voorgesteld in een andere context. Op die manier “Costs can be saved when re-using open data instead of paying for the data that is commercially published. In the Netherlands for example, users were charged approximately €63-€68 million for using the datasets from PSI providers such as the Dutch Chamber of Commerce, the Cadastre, the CBS (the Dutch national statistics agency) in 2009-2010. As these datasets are now freely available, users can save themselves these costs. Moreover, more people and organisations can start to use this data as the financial barrier is now removed.“. De voordelen zijn dus duidelijk voor de gebruikers als de voorheen betalende open data nu gratis worden. De voorwaarde is dat de overheid over de middelen beschikt om kwaliteitsvolle data te verschaffen die up-to-date en gedocumenteerd zijn. Dat is helemaal niet evident aangezien er geen zekerheid is dat de nieuwe gegenereerde inkomsten toegekend zullen worden aan de dienst die de Open Data verspreidt.

We kunnen vaststellen uit deze verschillende evoluties dat de bedenkingen, praktijken en de wetgeving wat betreft open data steeds matuurder worden. Open data is een topic op zich dat serieus opgevolgd moet worden in het kader van het eGovernment en dat van de burgermaatschappij of privésector. 

Het team Data Quality bij Smals staat ter beschikking om u te helpen bij het evalueren en verbeteren van de kwaliteit van de gegevens: de lezer kan meer informatie vinden over het competentiecentrum op de website van Smals (FR en NL).

Referenties

(1) Isabelle Boydens, Open Data et eGovernment. Research Note, Brussel, Smals, nr. 33, april 2014, 23 pp. (link naar het verslag en de samenvatting).

(2) Irène Bouhadana, William Gilles, Open Data. Toegangsrecht en hergebruik van openbare informatie in de datamaatschappij. Parijs, LexisNexis, 08/11/2023.

(3) Isabelle Boydens, Gani Hamiti en Rudy Van Eeckhout, A service at the heart of database quality. Presentation of an ATMS prototype. In Le Courrier des statistiques, Parijs, INSEE, 2023, nr. 6, 11 p. (gepubliceerd op 2/10/2023). Link naar het artikel.

Isabelle Boydens(*) et Isabelle Corbesier(**) 

(*) Data Quality Expert, Research Team

(**) Data Quality Analyst, Databases Team

Dit bericht is een gezamenlijke bijdrage van Isabelle Boydens, Data Quality Expert bij Smals Research en van Isabelle Corbesier, Data Quality Analysts bij Smals, Databases Team. Dit artikel is geschreven onder hun eigen naam en weerspiegelt op geen enkele wijze de standpunten van Smals.