Dans le monde de la programmation informatique, il existe une division de longue date entre deux manières de concevoir le code. D'un côté, il y a le travail pratique et quotidien consistant à écrire des instructions qui disent à une machine ce qu'elle doit faire, comme additionner des nombres ou déplacer des données. De l'autre côté, il y a le travail abstrait consistant à définir les règles et les structures qui régissent ces instructions, comme déclarer quels types de données sont autorisés. Pendant des décées, la plupart des langages de programmation ont maintenu ces deux mondes strictement séparés. Ils traitent les règles comme un cadre rigide qui n'existe que avant que le programme ne s'exécute, tandis que le travail effectif ne se produit qu'après. Cette séparation permet de garder les choses simples et rapides, mais elle force les programmeurs à écrire du code en double : une version pour les règles et une autre pour les actions. C'est comme devoir écrire un manuel pour une machine, puis écrire la machine elle-même dans deux langages complètement différents, même si ils décrivent la même chose.

Les chercheurs ont longtemps cherché un moyen de fusionner ces deux mondes, permettant aux règles et aux actions d'exister dans le même espace. Cela permettrait aux programmeurs d'écrire un code plus puissant et plus flexible, où les règles peuvent changer en fonction des données, et où les données peuvent influencer les règles. Cependant, cette unification a historiquement eu un prix élevé. Pour que le mélange des règles et des actions soit sûr, les ordinateurs doivent souvent s'arrêter et vérifier chaque étape d'un programme avant son exécution, un processus qui peut être incroyablement lent ou même impossible pour des tâches complexes. Alternativement, certains langages permettent ce mélange mais forcent le programmeur à renoncer à des fonctionnalités puissantes comme la capacité de répéter des actions indéfiniment, ce qui est essentiel pour de nombreuses applications du monde réel. La question demeure : est-il possible d'avoir un langage où les règles et les actions sont unifiées, tout en permettant à l'ordinateur de vérifier le code rapidement et de permettre des opérations répétitives puissantes ?

Une équipe de chercheurs de l'Université d'Oxford a construit un nouveau langage de programmation appelé Hippogriff qui répond à cette question par un oui retentissant. Ils ont créé un système qui unit avec succès les instructions de base d'un programme avec sa structure modulaire, permettant un niveau de flexibilité auparavant jugé incompatible avec une vérification rapide et fiable. La clé de leur succès est une astuce mathématique ingénieuse qui traite le moment de la vérification comme un état distinct du moment de l'exécution, sans forcer le programmeur à écrire dans deux langages différents. En utilisant un concept qu'ils appellent une « distinction de phase synthétique », les chercheurs ont conçu un langage où l'ordinateur peut regarder le code et comprendre sa structure instantanément, tout en permettant des opérations récursives complexes qui causeraient habituellement un plantage ou un blocage du système.

Les chercheurs n'ont pas seulement proposé une théorie ; ils ont construit une implémentation fonctionnelle d'Hippogriff pour prouver que cela fonctionne. Dans ce nouveau langage, un programmeur peut définir un type de donnée, comme une liste de nombres, puis utiliser immédiatement cette définition pour créer des fonctions qui opèrent sur elle, le tout au sein du même bloc de code. Le langage gère la complexité de ces définitions automatiquement. Par exemple, un programmeur peut écrire une fonction qui s'appelle elle-même de manière répétée pour traiter une liste, une caractéristique connue sous le nom de récursion, qui est souvent difficile à combiner avec un typage strict. Dans Hippogriff, cela est autorisé car le système est conçu pour ignorer certains détails lors de la phase de vérification qui n'affectent pas la structure globale, sautant ainsi efficacement les parties du code qui causeraient normalement un retard.

Cette approche contraste avec d'autres langages modernes qui ont tenté de résoudre des problèmes similaires. Certains langages, comme ceux utilisés dans les preuves mathématiques avancées, permettent ce type d'unification mais exigent que l'ordinateur évalue chaque étape du programme pendant la phase de vérification. Cela force le programmeur à s'assurer que chaque boucle et chaque fonction finit par s'arrêter, ce qui limite les capacités du langage. D'autres langages, comme ceux utilisés dans le développement de logiciels standards, gardent les règles et les actions séparées pour garantir la rapidité, mais cela force le programmeur à se répéter et limite la capacité du code à être dynamique. Hippogriff trouve un juste milieu en séparant la logique de la vérification de l'exécution du code. Il permet à l'ordinateur de vérifier la structure du programme sans avoir besoin d'exécuter les boucles potentiellement infinies qui pourraient se trouver à l'intérieur.

L'implémentation d'Hippogriff repose sur un choix de conception spécifique où le langage traite les types comme des valeurs. Cela signifie qu'un type, qui n'est généralement qu'une étiquette pour un genre de donnée, peut être passé et manipulé comme un nombre ou un mot. Cela pourrait sembler rendre le système chaotique, mais les chercheurs ont intégré un mécanisme de sécurité au cœur du langage. Ils se sont assurés que lorsque l'ordinateur vérifie si deux morceaux de code sont égaux, il ne regarde que les parties qui comptent pour la structure, ignorant les valeurs spécifiques qui pourraient changer ou boucler. Cela permet au système de rester rapide et prévisible. Si un programmeur tente d'écrire un code qui causerait un blocage de l'ordinateur dans une boucle infinie pendant la vérification, le langage traite simplement cette partie du code comme un espace réservé (placeholder) pendant la vérification, permettant à la validation de se terminer rapidement.

L'une des découvertes les plus significatives de l'article est que cette approche ne nécessite pas que l'ordinateur soit un oracle super-intelligent capable de prédire l'avenir d'un programme. Au lieu de cela, il utilise une méthode où l'ordinateur vérifie le code d'une manière similaire à la façon dont un humain pourrait lire un plan. L'humain regarde la structure globale pour voir si les pièces sont connectées correctement, sans avoir besoin de franchir chaque porte pour voir si elle s'ouvre. De même, Hippogriff vérifie les connexions entre les différentes parties du programme sans avoir besoin d'exécuter le code à l'intérieur de ces parties. Cela permet au langage de supporter des fonctionnalités telles que les « types dépendants », où le type de donnée dépend de la valeur d'une variable, une caractéristique qui a été difficile à implémenter dans les langages de programmation pratiques.

Les chercheurs ont également démontré que leur langage peut gérer des systèmes de modules complexes, qui sont des moyens d'organiser le code en blocs réutilisables. Dans de nombreux langages, créer un module capable de s'adapter à différents types de données nécessite beaucoup de code répétitif (boilerplate) et des règles strictes. Dans Hippogriff, ces modules peuvent être définis avec la même syntaxe utilisée pour les fonctions simples, rendant le code beaucoup plus concis et facile à lire. Le système gère automatiquement la complexité pour s'assurer que les modules s'assemblent correctement, même lorsqu'ils sont imbriqués les uns dans les autres ou lorsqu'ils se réfèrent à eux-mêmes. Ce niveau d'intégration n'était auparavant possible que dans des langages qui sacrifiaient soit la vitesse, soit la capacité d'écrire du code récursif complexe.

L'article traite également de la question de la gestion des erreurs par le langage. Parce que le système est conçu pour vérifier la structure du code sans l'exécuter, il peut fournir un retour d'information clair et immédiat au programmeur si quelque chose ne va pas. Si un programmeur commet une erreur dans la structure d'un type, le message d'erreur explique exactement où se situe le problème en termes du code qu'il a écrit, plutôt qu'en termes d'une traduction interne complexe que le programmeur n'a jamais vue. Cela rend le langage beaucoup plus convivial pour les développeurs qui souhaitent utiliser des fonctionnalités avancées sans être des experts en théorie sous-jacente.

Le travail présenté dans cet article n'est pas seulement un exercice théorique ; c'est une démonstration pratique que les barrières entre différentes manières de programmer peuvent être brisées. Les chercheurs ont montré qu'il est possible d'avoir un langage qui est à la fois puissant et sûr, combinant les meilleures caractéristiques de différents paradigmes de programmation. En utilisant une distinction de phase synthétique, ils ont créé un système où l'ordinateur peut comprendre l'intention du code sans s'enliser dans les détails de son exécution. Cela ouvre la voie à une nouvelle génération de langages de programmation plus expressifs et plus faciles à utiliser, permettant aux développeurs d'écrire un code qui est à la fois flexible et fiable.

Le succès d'Hippogriff suggère que l'avenir des langages de programmation pourrait résider dans ce type d'unification sémantique. Au lieu de forcer les programmeurs à choisir entre différents styles de codage, les langages peuvent évoluer pour supporter une approche unique et unifiée qui gère toutes les complexités automatiquement. Les chercheurs ont fourni un plan pour comment cela peut être fait, montrant que les fondements mathématiques sont solides et que l'implémentation est réalisable. Bien qu'il reste du travail à faire pour affiner le langage et le rendre encore plus ergonomique pour un usage quotidien, l'idée centrale a été prouvée. Le résultat est un langage qui semble naturel à écrire, même lorsqu'il effectue des vérifications complexes en arrière-plan, comblant ainsi le fossé entre le monde abstrait des types et le monde concret des valeurs.

En fin de compte, l'article présente une étape significative dans le domaine de la conception des langages de programmation. Il remet en question la croyance de longue date selon laquelle certaines fonctionnalités doivent être mutuellement exclusives et montre qu'avec les bons outils mathématiques, elles peuvent coexister. Les chercheurs ont construit un langage qui est non seulement théoriquement sain, mais aussi pratiquement implémentable, offrant un aperçu d'un futur où la programmation est plus intuitive et puissante. Le travail d'Hippogriff démontre qu'en repensant les hypothèses fondamentales sur la façon dont le code est vérifié et exécuté, nous pouvons créer des systèmes mieux adaptés aux besoins complexes du développement logiciel moderne. La voie à suivre est claire, et le potentiel d'innovation dans ce domaine est vaste.