Avant d’essayer d’écrire un DSL (Domain-Specific Language), il faut bien comprendre l’objectif de cette démarche.
Qu’est ce qu’un DSL ?
Un DSL est un langage de programmation qui a pour objectif d’adresser un domaine (un problème ?) bien précis. Toute tentative de l’utiliser dans un contexte en dehors de celui pour lequel il a été créé sera vaine.
Un DSL présente l’avantage de pouvoir rédiger du code de manière très expressive. De ce fait, son utilisation permet de transposer plus facilement le besoin exprimé par des fonctionnels en programme informatique. le travail est facilité pour les deux parties et de trouver un langage commun pour communiquer entre les deux mondes.
D’un point de vue plus général, il permet de rendre lisible et compréhensible une portion de code par des personnes non habituées à lire du code.
Aujourd’hui, beaucoup de frameworks se basent sur ce type d’approche :
– Fest-assert,
– LambdaJ,
– Guava,
– Op4j
– fluentLenium
– etc
L’article que je vous propose en lien aborde ce sujet sous l’angle du langage Java.
Les auteurs de cet article, +Alex Ruiz et +Jeff Bay, traitent plus précisément de l’écriture d’un DSL interne en Java.
Au travers de cet article, vous pourrez voir les différents points à comprendre et mettre en oeuvre pour créer un DSL basé sur le langage Java.
L’article a été écrit en 2008, ça date un peu, mais je pense que les concepts ainsi que l’approche à tenir évoqués sont toujours d’actualité et sont bon à connaître, même si nous n’avons pas forcément l’occasion d’avoir à écrire un DSL.
Dans un premier temps, les auteurs expliquent ce qu’est concrètement un DSL interne, ainsi que les avantages et inconvénients qu’il faut avoir à l’esprit en choisissant de l’écrire en Java.
Ensuite, vous pourrez trouver un exemple mettant en évidence l’avantage que présente l’utilisation d’un DSL. Le cas d’utilisation présenté est celui de l’écriture d’une requête SQL.
La troisième partie donne les ingrédients indispensables pour la création d’un DSL. Les éléments principaux qui compose un DSL sont :
– Une interface fluent,
– Le chainage de méthode
Ce paragraphe nous explique que les deux points identifiés ci-dessus ne sont pas suffisants pour qualifier à 100% que notre langage est un DSL.
Un exemple basé sur la StringBuilder (que l’on pourrait assimiler à une approche DSL) nous le démontre. En effet, cette classe, au travers de méthodes append() , propose le chaînage de méthode. En revanche, cette classe n’adresse aucun domaine spécifique.
Un point central (aussi) est l’utilisation de méthodes de factories statiques (import static). Ce dernier point permet, entre autres, de rendre le bloc de code plus lisible.
L’article nous expliquera en détail comment implémenter correctement le chaînage de méthodes ainsi que la mise en place de méthodes factories statiques.
Les deux derniers paragraphes sont consacrés à comment organiser le code du DSL et comment le documenter.
Dans la conclusion, les deux auteurs nous donnent leurs points de vue sur les DSLs écrits en Java. Ils expliquent que l’utilisation de Java pour écrire un DSL est un choix que l’on peut faire en fonction du contexte cible. Il faut mettre en balance les avantages et inconvénients que présente la solution.
Personnellement, je trouve cet article très intéressant sur le sujet abordé, les concepts donnés et les explications fournies sur la mécanique interne d’un DSL.
Coder's IO 