Je pense, moi aussi, que l'avenir est aux DSL (domain-specific languages), et plus precisement a un language unique permettant d'incorporer differents DSL simultanement dans un meme langage.
L'utilisation de certains DSL peut paraitre evident (comme cites ci-dessus: Xpath, SQL etc); ce qui l'est moins c'est l'utilisation de DSL integres au languages par exemple, des sous-langages permettant d'ecrire des parseurs comme Bison, ou des
extensions SQL a C). Peu de langages encouragent a l'utilisation systematique de DSL, a part Lisp (a ce propos, j'encourage fortement la lecture de On Lisp, de Paul Graham, disponible gratuitement sur internet).
Cette utilisation systematique permet effectivement de rendre les programmes de plus en plus declaratifs, et de permettre de faire des verifications au "compile-time".
Un exemple: un DSL precis pourrait etre les interfaces utilisees dans le noyau Linux.
Ce type de DSL permettrait de gerer plus facilement les changements d'interface binaires (pas besoin de retoucher aux sources), et permet de faire des verifications a la compilation (typage par exemple).
Utiliser un tel DSL n'est pas apprendre un nouveau langage; c'est extremement simple, et plus simple que d'apprendre a utiliser une librairie par exemple.
Le langage L (http://www.nongnu.org/l-lang , attention la page est un peu outdated) est concu pour pouvoir ecrire ce type de DSL. A titre d'exemple, voici un extrait d'un parseur ecrit dans le DSL de parseur:
Dans cet exemple, on mixe la DSL du parseur (permettant d'exprimer la grammaire) avec du code L (permettant d'exprimer des actions semantiques). Dans ce cas precis, on est en train de calculer la valeur des entiers parses tout en les parsant.
En resume, je pense que ce type de langage permet une plus grande surete, flexibilite, et facilite d'utilisation par la programmation declarative. Par contre, je ne pense pas que le langage naturel soit la cle, mais plutot d'avoir des syntaxes specifiques bien adaptees a chaque DSL.
Si vous etes interesses par ce type de langage, L est en plein developpement mais est deja fonctionnel (il dispose d'un compilateur dynamique, de DSL facilitant le developpement, et d'un translateur vers C, et une partie de L est deja ecrite en L);
un exemple de projet serait l'ecriture d'un DSL pour l'inline assembleur (qqchose qui fonctionne mieux que le asm de GCC, qui ne comprend pas l'assembleur inline).
[^] # Re: Superbe ! mai je me pose une question...
Posté par Matthieu Lemerre . En réponse au journal L'expressivité des langages. Évalué à 2.
L'utilisation de certains DSL peut paraitre evident (comme cites ci-dessus: Xpath, SQL etc); ce qui l'est moins c'est l'utilisation de DSL integres au languages par exemple, des sous-langages permettant d'ecrire des parseurs comme Bison, ou des
extensions SQL a C). Peu de langages encouragent a l'utilisation systematique de DSL, a part Lisp (a ce propos, j'encourage fortement la lecture de On Lisp, de Paul Graham, disponible gratuitement sur internet).
Cette utilisation systematique permet effectivement de rendre les programmes de plus en plus declaratifs, et de permettre de faire des verifications au "compile-time".
Un exemple: un DSL precis pourrait etre les interfaces utilisees dans le noyau Linux.
Par exemple, un driver reseau utilise ceci:
static struct pci_driver ne2k_driver = {
.name = DRV_NAME,
.probe = ne2k_pci_init_one,
.remove = __devexit_p(ne2k_pci_remove_one),
.id_table = ne2k_pci_tbl,
#ifdef CONFIG_PM
.suspend = ne2k_pci_suspend,
.resume = ne2k_pci_resume,
#endif /* CONFIG_PM */
};
L'utilisation d'un DSL pour les drivers PCI du noyau resulterai en qqchose comme ceci:
pci_driver ne2k = {
name : DRV_NAME;
probe : ne2k_pci_init_one;
remove : ne2k_pci_remove_one;
id_table : ne2k_pci_tbl;
suspend : ne2k_pci_suspend;
resume : ne2k_pci_resume;
}
Ce type de DSL permettrait de gerer plus facilement les changements d'interface binaires (pas besoin de retoucher aux sources), et permet de faire des verifications a la compilation (typage par exemple).
Utiliser un tel DSL n'est pas apprendre un nouveau langage; c'est extremement simple, et plus simple que d'apprendre a utiliser une librairie par exemple.
Le langage L (http://www.nongnu.org/l-lang , attention la page est un peu outdated) est concu pour pouvoir ecrire ce type de DSL. A titre d'exemple, voici un extrait d'un parseur ecrit dans le DSL de parseur:
grammar Numeric = {
rule Digit:Character = d:[0-9] { d - Character( '0')};
rule Decimal_Number:Int = n:( d:[1-9] {d - Character( '0')})
(d:Digit {{n = n*10; n = n+d}})* {n};
rule Hexa_Digit:Character = (Digit | d:[a-f] { d - Character( 'a')});
rule Hexadecimal_Number:Int = "0x" n:{0}
(d:Hexa_Digit {{n = n*16; n = n+d}})* {n};
rule Number:Int = Decimal_Number | Hexadecimal_Number
}
Dans cet exemple, on mixe la DSL du parseur (permettant d'exprimer la grammaire) avec du code L (permettant d'exprimer des actions semantiques). Dans ce cas precis, on est en train de calculer la valeur des entiers parses tout en les parsant.
En resume, je pense que ce type de langage permet une plus grande surete, flexibilite, et facilite d'utilisation par la programmation declarative. Par contre, je ne pense pas que le langage naturel soit la cle, mais plutot d'avoir des syntaxes specifiques bien adaptees a chaque DSL.
Si vous etes interesses par ce type de langage, L est en plein developpement mais est deja fonctionnel (il dispose d'un compilateur dynamique, de DSL facilitant le developpement, et d'un translateur vers C, et une partie de L est deja ecrite en L);
un exemple de projet serait l'ecriture d'un DSL pour l'inline assembleur (qqchose qui fonctionne mieux que le asm de GCC, qui ne comprend pas l'assembleur inline).