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!

Tegenwoordig gebruikt men voor het bouwen van een website of web-applicatie technologie die heel anders is dan 20, 10, of zelfs 5 jaar geleden. Anderzijds zijn er een paar zaken nog altijd hetzelfde. Bovendien gebruikt men deze technologie om steeds nieuwe, en vaak complexere en mooiere sites en applicaties te bouwen – maar anderzijds maakt men ook nog altijd eenvoudige websites. In deze blobg bespreken we een recente evolutie die al een handvol jaren komende is, we noemen deze de “Frameworks Blob”.

To Enterprise, or not to Enterprise?

Wat het bouwen van websites en webapps betreft, volg ik al een tijdje welke zaken hip zijn, welke zaken uit de mode geraken, en welke zaken er in de nog aparte wereld van “Enterprise” development gebeuren. Naar mijn mening vindt er nu een interessante evolutie plaats: meer en meer professionele software huizen (“enterprises”, dus) gebruiken – of bekijken op z’n minst – technologie die minder als “Enterprise” technologie gezien wordt.

Maar wat is Enterprise technologie dan wel? Volgens de definitie is het eigenlijk gewoon ‘technologie ontwikkeld op maat van bedrijven i.p.v. individuele gebruikers’. Waar velen van ons – of ik toch – echter aan denken wanneer we het woord “Enterprise-ready” horen vallen is: matuur, stabiel, zwaar, complex, full-blown en moeilijk. Kortom, technologie die, beter dan andere, goed werkt als ze goed gebruikt wordt, maar niet fijn is om goed te gebruiken.

Anno 2010, Blob as Usual

Op onderstaand assenstelsel heb ik weergegeven op welke manier de meeste applicaties worden ontwikkeld. De horizontale as toont de complexiteit van de website of -app: links heb je de meest eenvoudige websites, rechts de meest complexe en “mastodontale” web-applicaties. Op de verticale as heb ik een aantal technologieën, talen, pakketten, methodologieën… kortom bouwstenen geplaatst die kunnen worden gebruikt om deze webprojecten mee te ontwikkelen. Bovenaan staan de eenvoudigste: zaken zoals Html, de elementaire bouwsteen van het web, en Javascript, een taal die men rechtstreeks in de browser kan gebruiken. Onderaan vinden we meer en meer “enterprisey” technologieën terug: zaken zoals SOAP, J2EE en – huiver – Cobol (jawel, zelfs voor web 2.0). Het is uiteraard voor discussie vatbaar waar welke bouwsteen juist op deze as thuishoort. Bovendien kunnen dergelijke technologieën en talen verschuiven op deze as: ze kunnen minder, of juist meer “enterprisey” worden, naarmate ze matuur worden.

De groene “Blob” tenslotte, is waar, volgens mij, het grootste gewicht van alle web development gebeurt: traditioneel en logischerwijs worden dus de meeste eenvoudige sites en applicaties met eerder eenvoudige technologieën gebouwd. Zware en complexe applicaties worden echter – vaak terecht – met enterprise-ready technologieën gebouwd. Business as Usual…

 Anno 2014, the Blob deforms…

Zoals in het begin reeds gezegd: meer en meer web development schuift weg van technologie die te “Enterprise” is, richting lichtere raamwerken die alles in het werk stellen om het bouwen van webapplicaties zo snel en eenvoudig mogelijk te maken. In de onderstaande figuur vertaalt zich dit in een verschuiven van de onderkant van de “blob” naar boven toe: dus ook voor complexere applicaties worden nu meer en meer lichtere en kleinere bouwstenen gebruikt.

Wat we bovendien ook nog zien, is een soort van deformatie; een bochel op de blob, als het ware. Deze wordt veroorzaakt door de recente evolutie van de Javascript raamwerken, zoals AngularJS en Meteor. Deze raamwerken baseren zich op de meest eenvoudige technologieën (Html, Javascript en Css), maar bieden tegelijk een zeer krachtige ontwikkelaarservaring, waardoor men via weinig werk toch enorm veel resultaat kan boeken. Het zal dus niet verbazen dat steeds meer web-projecten van dit soort raamwerken gebruik maken, zeker als het gaat om het beheersen van complexiteit. En dat verklaart dus meteen de bult op de blob!

Zal de blob in de toekomst nog op andere manieren vervormen? De Kerstman kan het ons misschien vertellen…

Vrolijk Sinterklaasfeest  !

Nochtans is Javascript qua programmeertaal niet meteen het neusje van de zalm… Een paar quotes:

• “JavaScript is a language with more than its share of bad parts.”
• “Few classical programmers found prototypal inheritance to be acceptable, and classically inspired syntax obscures the language’s true prototypal nature. It is the worst of both worlds.”
• “undefined and NaN are not constants. They are global variables, and you can change their values. That should not be possible, and yet it is. Don’t do it.

(Uit: Douglas Crockford, JavaScript: The Good Parts )

Er zijn uiteraard ook goede delen aan Javascript (anders zou dat boek toch wel anders heten), maar al bij al zal Javascript geen schoonheidsprijzen in de wacht slepen. Het is een dynamisch getypeerde taal, met prototypische overerving, en het is erg gemakkelijk in Javascript om je programma heel onleesbaar te maken. Programmeurs die met een meer klassieke taal beginnen werken, zoals Java, en daarna pas Javascript leren, moeten typisch serieus wennen (en ontwennen)!

De twee talen zijn trouwens, ondanks de naam en enkele gelijkenissen (e.g. dat ze beide een C-achtige syntax hebben), niet gerelateerd (men zou kunnen zeggen: Javascript en Java zijn zoals Parket en Park). Javascript kreeg zijn naam indertijd van NetScape in de hoop op de toenmalige populariteit van Java te kunnen piggybacken.

Tegenwoordig zijn er ook al verschillende talen die de syntactische tekortkomingen van Javascript trachten op te vangen: het zijn talen die sterk op Javascript lijken, en er ook in worden vertaald wanneer het tijd wordt om de code uit te voeren. Voorbeelden zijn CoffeeScript en Dart. Voorlopig zijn deze talen echter nog maar weinig in gebruik in vergelijking met het origineel.

Waarom is Javascript dan zo populair? Dat heeft een aantal redenen. De belangrijkste daarvan is de V8 engine, die zijn intrede maakte in Google Chrome. Deze engine (hetgeen wat de code daadwerkelijk uitvoert) heeft de performantie van de taal naar een nieuw niveau geheven, en wordt trouwens ook gebruikt in node.js. Daarnaast is het uiteraard zowat de enige taal die nog gebruikt wordt om code uit te voeren in de browser zelf (aan de “client side”), wat, in een goed gebouwde website, de server en het netwerk serieus kan ontlasten, terwijl er toch een mooie en interactieve site of applicatie wordt gepresenteerd.

Een paar positievere quotes:

• de wet van Jeff Atwood: “any application that can be written in JavaScript, will eventually be written in JavaScript“
•  “After some abandoned experiments with static compilation, we looked around and saw how successfully JIT techniques are being applied in the JavaScript space: Chrome’s V8 engine, in particular, has greatly pushed the status quo of JavaScript performance.” – anoniem

Javascript viert volgend jaar al z’n twintigste verjaardag… De taal werd vrij snel populair in het begin en er werd zelfs een standaard voor geschreven. Toch keken “echte” developers een tijdlang neer op de taal. Een grote doorbraak kwam er dankzij AJAX (Asynchronous JavaScript and XML), een technologie die toelaat om niet bij elke communicatie met de server opnieuw de volledige webpagina te moeten laden. Deze technologie heeft een beetje een evolutie gekend voorheen, maar kreeg voor het eerst haar naam in 2005. Sindsdien is de groei van Javascript als taal van het web niet meer te onderschatten.

AJAX op zijn beurt heeft geleid tot twee recentere ontwikkelingen die de dominantie van de taal nogmaals onderstrepen: moderne Javascript raamwerken (Frameworks) en server-side Javascript onder de vorm van Node.js.

Frameworks

Websites bouwen met interactieve en dynamische graphics was vroeger erg moeilijk, maar daar zijn nu Javascript raamwerken voor. Het begon vooral in 2006 met JQuery: een Javascript pakket dat het een stuk eenvoudiger maakte, en nog altijd doet, om mooie zaken op het scherm te presenteren. JQuery evolueert nog steeds, en is ondertussen geïntegreerd geraakt in tal van andere pakketten en frameworks. Niet in het minst ligt JQuery aan de basis van zowat alle recentere Javascript raamwerken die het ontwikkelingsgemak nog een stapje verder nemen.

Bootstrap.js

Bootstrap werd oorspronkelijk ontwikkeld door Twitter, en in 2011 open source gemaakt. Het bestaat uit een collectie aan tools voor het ondersteunen van het bouwen van websites en -apps, vooral gebaseerd op templates voor allerlei UI-elementen. De huidige versies hebben een goede ondersteuning voor responsive design en hanteren de mobile first strategie.

Backbone.js

Backbone bestaat al sinds 2010 als Javascript raamwerk en volgt iets dat lijkt op het model-view-controller (MVC) principe. Het ondersteunt en vereenvoudigt ook de verbinding via REST van de front-end met de backend van de te ontwikkelen site.

Het is vrij populair geworden en wordt momenteel zelfs in de core van Drupal 8, het populaire CMS, ingebouwd.

AngularJS

Angular is een raamwerk dat zich focust op het via Javascript uitbreiden van het html-model van een website. Zo kan je via eenvoudige, zelf gedefiniëerde extra sleutelwoorden in de html-pagina tonnen functionaliteit toevoegen zonder aan de overzichtelijkheid van het html-model te raken. Er wordt op die manier ook een heel niveau van herbruikbaarheid toegevoegd aan web-ontwikkeling.

Node.js

Voor de allereerste keer is Javascript niet alleen aan de client side, maar ook op de server enorm populair aan het worden. Dit komt doordat het gebruik van node.js verschillende voordelen heeft:

• Efficiëntie en compatibiliteit: er moet niet langer telkens een vertaalslag worden uitgevoerd tussen de gegevens die op de server staan en degene in de browser: alles is in javascript, dus de manier waarop data wordt gerepresenteerd, is voor de client en de server hetzelfde (typisch gebeurt dit met json). Voor de vertaalslag hoeft dus ook geen code meer te worden geschreven. Daarnaast is een node.js server ook vrij performant: één server kan zeer veel requests van clients tegelijk afhandelen.
• Leercurve: Developers hoeven nog maar één programmeertaal te leren alvorens ze een volledige webapplicatie kunnen bouwen. Niet langer moeten ze een server-taal leren, zoals php of java, en daarnaast nog eens Javasript voor de client.

Dit laatste heeft trouwens ook zijn impact op de Javascript frameworks: nu zijn er al frameworks die zich niet alleen op de client, maar op de volledige stack richten, puur in Javascript: Meteor is zo’n framework.

Zal Javascript verder de wereld veroveren en misschien zelfs php naar de kroon steken? Dat is moeilijk te voorspellen, de wereld van web development verandert razend snel. Een Javascript framework dat vandaag populair is kan over een paar jaar al ouderwets lijken in vergelijking met nieuwere frameworks. We kunnen alleen maar besluiten dat we het door deze snelle evoluties allicht steeds makkelijker zullen hebben om goed werkende webapplicaties te ontwikkelen, en dat het gebruik van een modern Javascript framework, of eventueel zelfs van node.js, een te overwegen optie is bij quasi alle web projecten.