Un petit langage ZdS

Salut à tous,

C'est mon cas mais je sais que je ne suis pas le seul ici, plus que quelques semaines et ce sera la fin des cours et des exams. De quoi profiter des vacances pour passer un peu de temps à coder !

Je viens ici pour vous proposer un atelier : la création d'un petit langage de programmation. L'objectif n'est pas de créer le futur gros langage, mais de s'amuser, et d'apprendre. L’idéal serait que tout le monde puisse participer : débutant ou personnes expérimentées.

Si le projet plaît, et que plusieurs personnes sont motivées pour s'y lancer, on pourra alors débuter la spécification de notre langage, avant de se lancer dans l'implémentation et les choix techniques. Il faudra éviter de partir dans tous les sens.

Encore une fois, je me répète : l'objectif est de s'amuser, de participer à ce projet dans la bonne humeur, et de découvrir de nouvelles choses. Si notre petit langage arrive à effectuer quelques opérations basiques et qu'il est utilisable, alors tout sera réussi.

Mais tout d'abord, êtes vous intéressé ? Avez-vous des suggestions concernant le projet ?

Bonjour,

Projet qui peut être très intéressant et enrichissant ! Cependant peux-tu préciser quelques points (notamment sur les compétences attendues, du moins quelles techno' vont être utilisée…) ?

Merci à toi,

Pas de compétences particulières attendues. Ce projet peut être une bonne occasion d'apprendre !

Concernant les technos utilisés, ça dépendra. Tout dépendra des personnes qui participent au projet, ainsi que des objectifs que nous nous serons fixés durant la phase de spécification.

À quel moment on commence à s’entre-tuer pour savoir si on fait un langage objet / fonctionnel, avec typage statique / dynamique ?

C'est la question

Je pense justement qu'il peut être très intéressant de discuter de ces points, en fonction des petits objectifs que l'on pourra se fixer.

Effectivement, ça serait intéressant je voudrai bien y participer Mais comment cela se passe ? Le code sera regroupé sur github ? Quel système de communication ? …

Avec garbage collector ou sans ? J'ai lu une jolie discussion des avantages et inconvénients du GC (qui part en troll, comme toujours sur linuxfr).

Si le but est de s'amuser et d'apprendre, je pense que le mieux est de se focaliser sur un objectif, et de trouver les moyens d'y parvenir, en oubliant le reste (de toute façon, le but n'est pas de s'en servir dans des vrais cas).

Par exemple, on veux qu'un programme soit avec de très fortes garanties d'absence de bug ou d'erreur de segmentation s'il compile, dans ce cas on peut partir sur de la programmation fonctionnelle ou par contrat. Ou alors qu'il soit parallélisé automatiquement à la compilation.

Tout en gardant à l'esprit que créer un langage de programmation, c'est très vite compliqué (bon bagage sur la question est proche de 0).

Le code sera regroupé sur github ? Quel système de communication ? …

Avant de commencer à coder quoi que ce soit, il faudra passer par une importante étape de spécification. Mais dans l'idée, le code sera bien sûr open-source, et GitHub me semble la meilleure option.

Tout en gardant à l'esprit que créer un langage de programmation, c'est très vite compliqué

On est tout à fait d'accord, c'est pour ça qu'il faudra absolument éviter de partir dans tous les sens.

Mon idée de départ serait de partir sur un langage basique, (de préférence de haut niveau), et de le faire évoluer progressivement. Je suis donc tout à fait ouvert si vous avez d'autres suggestions, des idées.

<troll>Multi-paradigme, comme le C++ ? </troll>

Sinon, j'en suis, même si je ne pourrai pas forcément énormément contribuer.

Pareil, je serais intéressé de participer, car c'est quelque chose que je ne connais pas du tout et qui me plairais de découvrir.

De ce que j'ai pu voir sur internet il n'existe vraiment pas beaucoup de tutoriel à ce niveau.

Malgré que les langages que j'utilise ne seront surement pas utiliser, il peut être intéressant de découvrir de nouvelle chose

L'idée est intéressante, mais le projet n'est-il pas un peu trop ambitieux ? Dans un premier temps, ne serait-il pas préférable d'aborder les principes de base de la compilation sur des exemples simplifiés ?

L'idée est intéressante, mais le projet n'est-il pas un peu trop ambitieux ?

Je ne prétend absolument pas créer un langage complet, ce serait bien trop complexe. Ici, on travaillerait plutôt sur des points précis.

Dans un premier temps, ne serait-il pas préférable d'aborder les principes de base de la compilation sur des exemples simplifiés ?

C'est à dire ? L'idée, c'est de prendre les problèmes uns par uns, et de réfléchir ensemble à la solution à mettre en place.

Par exemple, les opérations mathématiques.

• Première étape, phase de spécification. On réfléchit sur ce que l'on souhaite, les comportements attendus ;

• Deuxième étape, on réfléchit sur le meilleur moyen d'implémenter ça, tout en respectant la petite spécification établie plus tôt ;

• Troisième étape, on code ! On met en place tout ce qui a été défini plus haut.

Je pense que c'est le meilleur moyen de procéder. Si vous avez d'autres suggestions, n'hésitez pas !

C’est un peu mon problème : comment définis-tu la répartition entre les problèmes ? Par exemple, dans un langage comme Haskell, les opérations mathématiques sont des fonctions comme les autres. Ce n’est qu’au moment de l’implémentation qu’on leur réserve un sort spécial, parce que ce serait vraiment tout pourri en termes de perfs de représenter l’addition comme une répétition de fonctions « successeur » sur un type « entiers de Peano ».

Du coup, comment comptez-vous définir ce que sont les problèmes à régler ? Ne serait-il pas plus adéquat de d’abord définir les grandes caractéristiques du langage, et de voir quels problèmes en découlent ?

Pour la phase de spécification, tu comptes utiliser les outils de la théorie des langages (automates, grammaires, etc.) ?

Bonjour,

J'ai déjà essayé plusieurs fois de m'amuser à la conception d'un mini-langage sans vraiment y parvenir. Je crois que le piège principal c'est de s'auto-troller sur la syntaxe et le parsing plutôt que de s'intéresser à ce qui est vraiment important genre le système de type, la VM ou le GC. En tout cas dans tout ce que j'ai eu commencé, je me suis à peu près toujours embourbé sur les questions de parsing sans jamais pouvoir aller beaucoup plus loin dans ce qu'il y a dans le vrai coeur du langage.

De l'extérieur, mon mini-langage le plus abouti ressemblait à ça :

1
2
3
4
5
6

def f (int x) -> int: 3x+4
def g (int x) -> int: 2(x -1)
def h (int a, int b) -> int {
if a>b: f(a)+g(b)
else { a=g(a); b=f(b); f(a)*g(b) }
}```

Mais vu que le parsing était fait à la main (pas de lex/yacc ou de truc similaire parce que je n'ai jamais eu la patience d'essayer d'apprendre ces outils), n'importe quelle instruction était suceptible de faire tout planter plus ou moins aléatoirement; ou alors des instructions plus ou moins incongrues étaient acceptées sans que je ne comprenne trop pourquoi.

ON devrait peut-être s'intéresser à un langage simple genre lua. Pas forcément pour sa syntaxe, mais surtout pour la manière dont il est conçu. Il a l'avantage d'être simple, mais assez complet et somme toute avec des mécanismes pas si anodins que ça (je pense notamment aux métatables et aux coroutines).

Je me rappelle d'un mec qui avait posté sur OC à propos d'un langage qu'il avait baptisé Jade. La discussion était super intéressante, son travail avait l'air hyper abouti mais il n'a jamais rien mis en téléchargement… depuis ça n'a jamais vraiment cessé de m'interpeler.

Du coup, comment comptez-vous définir ce que sont les problèmes à régler ? Ne serait-il pas plus adéquat de d’abord définir les grandes caractéristiques du langage, et de voir quels problèmes en découlent ?

Si, désolé, ça me semblait évident. On définit les grosses lignes du langage, et on s’attaque aux différents problèmes progressivement.

De toutes façons, sans vouloir être pessimiste, il faudra certainement plusieurs essais avant d'arriver à une implémentation fiable de ce que l'on aura défini.

Ça serait pas plus simple de commencer par très petit (par exemple une calculatrice) et d'augmenter petit à petit ?

Et puis je ne sais pas trop comment vous allez vous occuper de ça, mais il ne faut pas que les plus "avancés" fassent tout. Puis si on est trop nombreux ça va être difficile de servir à quelque chose, étant débutant. Pourquoi pas faire des petits groupes ?

Je me rappelle d'un mec qui avait posté sur OC à propos d'un langage qu'il avait baptisé Jade. La discussion était super intéressante, son travail avait l'air hyper abouti mais il n'a jamais rien mis en téléchargement… depuis ça n'a jamais vraiment cessé de m'interpeler.

Il avait fait un reboot du projet (en changeant de nom) et si, il y a les sources en téléchargement ici.

C'est globalement l'idée, avancer petit à petit.

Et puis je ne sais pas trop comment vous allez vous occuper de ça, mais il ne faut pas que les plus "avancés" fassent tout. Puis si on est trop nombreux ça va être difficile de servir à quelque chose, étant débutant. Pourquoi pas faire des petits groupes ?

Plus on est de fous, plus on rit ! Vraiment, tout le monde peut y prendre part. Je suis moi même loin d'être dans un expert dans le domaine. De plus, si tout est open-source, tout le monde pourra participer à sa hauteur. Aussi, on pourrait éventuellement imaginer différentes implémentations. Il y a plein de possibilités !

Selon le nombre de personnes participantes au projet, je trouve que faire des groupes comme l'a proposé ThuleMalta est une excellente idée ! Mettre par exemple une/des personne(s) ayant un niveau confirmé dans un groupe et une/des personne(s) plus débutante(s) pour que tout le monde puisse y trouver son compte

Pour la phase de developpement, pourquoi ne pas faire un repo github (je vais devoir me recreer un compte…) gere par un petit groupe de mainteneurs, les developpeurs avances, et chacun ferait des pull requests ?

Pour la phase de developpement, pourquoi ne pas faire un repo github (je vais devoir me recreer un compte…) gere par un petit groupe de mainteneurs, les developpeurs avances, et chacun ferait des pull requests ?

C'est l'idée, oui.

Mais avant de faire des groupes ou toute autre chose, il faut spécifier le langage, lui définir une philosophie propre, ses principales caractéristiques.

Perso, pour faire simple, j'aimerais bien un langage impératif, avec un syntaxe de haut niveau, simple et facile à prendre en main. Je serais également favorable à un typage dynamique. Objectif principal : être intuitif.