Le langage de programmation Racket

 (racket-lang.org)
2 points par GN⁺ 2024-04-22 | 1 commentaires | Partager sur WhatsApp
  • Racket est un langage mature centré sur la programmation orientée langage, qui traite le développement d’applications générales et la création de nouveaux langages au sein du même écosystème
  • Son cœur repose sur les macros et #lang : nouvelles syntaxes, langages dédiés à un domaine et syntaxes de surface existantes peuvent être créés comme des bibliothèques et utilisés au niveau des modules
  • Sa bibliothèque standard, qui couvre serveur web, bases de données, mathématiques et statistiques, GUI et simulations scientifiques, ainsi que des milliers de packages, élargit son champ au développement généraliste
  • Typed Racket, les contrats, le système d’objets et l’IDE DrRacket sont fournis ensemble, ce qui permet de combiner selon les besoins code fonctionnel, composants orientés objet et typage graduel
  • Racket n’est pas simplement un langage de la famille Lisp : il se rapproche d’un environnement de développement visant à créer des langages adaptés à chaque domaine de problème et à les relier à l’exécution, à l’édition et au support des outils

Racket pour la programmation orientée langage

  • Racket est un langage de programmation qui met en avant à la fois « Racket, the Programming Language » et « Racket, the Language-Oriented Programming Language »
  • Racket version 9.2 est disponible
  • C’est un produit mature qui prend en charge depuis le début la programmation graphique multiplateforme sous Windows, macOS et Linux
  • Les fonctionnalités de développement de base incluent la gestion des packages, les GUI, les binaires autonomes et les interfaces externes

Périmètre du développement d’applications généralistes

  • Racket dispose d’un ensemble de bibliothèques couvrant aussi bien les applications de serveur web que les mathématiques et les logiciels de simulation scientifique
  • Les principales documentations et bibliothèques couvrent notamment :
  • Une boîte à outils GUI multiplateforme et un serveur web font partie de l’écosystème de base
  • Des milliers de packages supplémentaires peuvent être installés avec une seule commande
    • On y trouve par exemple 3D graphics, Bluetooth socket connector, color maps, data structures, educational software, games, quantum-random number generator, scientific simulations et web script testing
  • L’exemple #lang racket/gui implémente un petit jeu de devinette de nombres dans un dialecte GUI et utilise plusieurs fonctionnalités du langage ensemble

Un langage extensible par macros

  • Les programmeurs Racket peuvent définir leurs propres boucles et nouvelles syntaxes avec des macros
  • Une nouvelle syntaxe s’ajoute comme une procédure, une méthode ou une classe : il suffit de créer des règles qui réécrivent une syntaxe personnalisée en expressions ou définitions Racket
  • Les petites macros aident à éliminer le code répétitif difficile à traiter avec d’autres mécanismes
    • On peut définir une syntaxe time-it pour mesurer le temps d’exécution d’une tâche
    • On peut éviter l’usage répétitif de lambda
    • Les macros sont exportées depuis les modules comme des fonctions ordinaires
  • Le système de macros complet permet aussi de construire des structures où plusieurs macros coopèrent
  • Racket est un langage fonctionnel, mais il fournit dès l’origine un sous-langage avec classes and objects, mixins and traits
  • Le système de classes proche de Java est implémenté comme une bibliothèque fondée sur les macros, sans prise en charge séparée dans le langage cœur

#lang et langages dédiés à un domaine

  • Racket se veut un langage pour créer des langages, afin que les programmeurs puissent écrire chaque module dans le langage approprié
  • L’exemple #lang typed/racket utilise un type union de String et Number, l’occurrence typing et le filtrage de listes
  • L’exemple #lang scribble/base traite un langage de documentation qui génère des documents PDF ou HTML
  • L’exemple #lang datalog utilise la syntaxe Datalog pour définir et interroger les relations parent et ancestor
  • Un nouveau langage peut être créé dans une fenêtre d’IDE et les modules de ce langage exécutés dans une autre fenêtre d’IDE, sans configuration, fichiers de projet ni outils externes
  • Les utilisateurs de Racket emploient principalement une syntaxe à parenthèses, mais il est aussi possible de créer des syntaxes de surface existantes nécessitant virgules et accolades, comme Datalog
  • Les packages de parsing permettent de mapper une grammaire arbitraire vers un langage fondé sur les parenthèses, puis de la compiler en Racket ordinaire avec le système de macros de Racket

DrRacket et l’écosystème de développement

  • Racket fournit son propre IDE, DrRacket, avec une fonction qui trace une flèche vers l’emplacement de définition lorsqu’on survole un identifiant à la souris
  • Même avec des langages alternatifs comme Typed Racket, on peut utiliser l’assistance à l’édition de DrRacket
  • Les macros Racket enregistrent et propagent suffisamment d’informations de source, même dans les macros complexes ou les macros créant de nouveaux langages, pour que DrRacket puisse se comporter comme s’il comprenait les fonctionnalités du nouveau langage
  • Les principaux supports de développement sont :
  • Les ressources de l’écosystème incluent le téléchargement, le code source, les rapports de bugs, les nightly snapshot builds et le dépôt de packages
  • Les ressources d’apprentissage et la documentation proposent Quick Introduction, The Racket Guide, The Racket Reference et All Documentation
  • Les canaux communautaires comprennent Discourse, Discord, Slack, Reddit, les mailing lists, Mastodon, Twitter, Blog, Wiki et YouTube, ainsi que des documents sur l’équipe et la contribution

À lire aussi

1 commentaires

 
GN⁺ 2024-04-22
Avis de Hacker News

  • Content de voir Racket arriver en première page. Depuis 1982, j’utilise surtout Common Lisp pour la programmation de recherche, mais ces derniers temps je me tourne plus souvent vers Racket
    Il y a aussi des choses que je n’aime pas dans Racket : à peu près tout, sauf le compilateur, le système de gestion de paquets, l’IDE graphique, les raccourcis Emacs, et le fait que ce soit un langage agréable à écrire
    L’écosystème lié à la recherche sur les langages de programmation ne m’intéresse pas vraiment, et c’est sans doute ce à quoi les professeurs d’informatique qui dirigent le projet accordent le plus d’importance. Cela dit, je leur souhaite de réussir
    J’ai donc aussi l’impression de profiter gratuitement du projet Racket. Je me contente des petites parties que j’aime, j’ignore le reste, et je ne contribue presque pas. À la rigueur, le petit livre sur Racket que j’ai écrit peut être une exception

    • Je suis d’accord avec presque tout ça. Grâce au système de gestion de paquets, à l’IDE graphique avec débogueur pas à pas, à la capacité d’écrire un IDE multiplateforme maintenu directement par l’équipe cœur de Racket, et à la facilité de créer des binaires exécutables, Racket est mon Lisp préféré
      Ces fonctionnalités sont vraiment utiles et importantes. J’aime Lisp, mais au travail je n’utilise un langage que lorsqu’il est l’outil le plus adapté à la tâche. Grâce à ces fonctionnalités, Racket a été le seul Lisp dont j’ai pu justifier l’usage en pratique
      Grâce à sa communauté, ses outils et ses ressources d’apprentissage, Racket est pour moi un langage facile à recommander aux autres. J’ai aussi beaucoup utilisé CL et Clojure, et il y a des choses que j’aime dans chacun, mais ils ont chacun de gros défauts, donc je ne les recommande pas
      Moi non plus, je ne me retrouve pas vraiment dans la partie recherche du langage ni dans la fonctionnalité lang, et je n’aime pas beaucoup HtDP non plus. Mais je vois ça comme des projets qui ne m’intéressent pas, construits avec un langage que j’aime, pas comme des défauts du langage lui-même. En pratique, on les rencontre très rarement
    • https://leanpub.com/racket-ai/read
      À ce niveau-là, on peut considérer que c’est une contribution remarquable :)
    • J’utilise CL au quotidien, et pas dans la recherche ni dans la recherche sur les langages de programmation. Je n’ai encore jamais essayé Racket ; je serais curieux que tu détailles davantage ce que tu n’aimes pas dans Racket par rapport à CL
    • Je me demande ce que signifie exactement l’écosystème de recherche sur les langages de programmation. Dans la distribution Racket, la seule chose que je vois qui relève clairement de la recherche sur les langages de programmation, c’est à peu près Redex
      Le langage lui-même a des fonctionnalités de métaprogrammation, mais tous les langages modernes en ont
      Mon expérience de la communauté, ce sont surtout des gens qui parlent de problèmes concrets
      Comme Racket est utilisé dans la recherche sur les langages de programmation et dans d’autres recherches, il est mentionné dans des articles et des présentations de conférences liés au sujet, mais il ne domine pas les discussions
      Exemple : https://racket.discourse.group/t/levin-tree-search-with-cont...
    • À l’université, j’ai utilisé Racket dans un cours sur l’écosystème des langages de programmation, et cet aspect-là ne m’a pas beaucoup plu non plus. Cela dit, Racket est facile à prendre en main et remplit clairement bien son rôle. Si l’on veut mettre un pied dans Lisp, je pense personnellement que Racket est un bon point de départ
      Clojure a toutefois une communauté plus grande et plus solide. En revanche, comme il utilise la JVM, la configuration est un peu plus fastidieuse, avec aussi davantage de subtilités à surveiller

  • Racket est un langage très pragmatique. S’il vous donne l’impression d’être une lubie académique, regardez ce que Bogdan Popa fait avec Racket : https://defn.io/
    Personnellement, quand j’ai besoin d’un binaire avec une GUI native, j’utilise Racket. Il est aussi plutôt bon pour parser des choses comme JSON, XML ou des formats de fichiers texte
    Le livre à lire en parallèle, How to Design Programs, https://htdp.org/2023-8-14/Book/index.html, est également bon. Ce n’est pas exactement un livre qui enseigne Racket ; il utilise plutôt quelques langages pédagogiques implémentés en Racket, mais il contient des idées intéressantes qui valent la peine d’être revisitées de temps en temps
    Le système de macros peut sembler étrange à quelqu’un qui vient de CL ou d’un langage similaire, mais une fois habitué, j’ai trouvé qu’il permettait de faire de la métaprogrammation tout en restant relativement sain d’esprit
    Quelques autres ressources utiles :
    https://www.greghendershott.com/fear-of-macros/
    https://beautifulracket.com/

    • Y a-t-il quelque chose de particulièrement marquant chez Bogdan ? En survolant rapidement, rien ne m’a vraiment sauté aux yeux

  • J’aime vraiment le langage Racket, mais le flux de travail imposé est difficile à accepter. Quand je code en Python, j’écris le code dans un éditeur et je l’exécute dans le shell
    Racket met tellement de temps à démarrer que ça ne marche pas très bien comme ça. On dit plutôt qu’il faut interagir avec une machine virtuelle de longue durée et un REPL
    Mais dans ce cas, le code sur lequel on travaille ne démarre pas dans un état propre, il démarre depuis l’état que possède la machine virtuelle à cet instant. C’est un excellent flux pour des choses comme les notebooks Jupyter, mais je pense que ça convient mal aux gros programmes

    • Écrire le code dans un éditeur et l’exécuter dans le shell est aussi une approche tout à fait valable avec Racket. D’après mon expérience, le temps de démarrage est assez comparable à celui de Python. C’est lent, mais pas rédhibitoire, et c’est particulièrement correct si l’on précompile. C’est utile pour les fichiers sur lesquels on a terminé de travailler pour le moment
      Utiliser le #lang racket/base au lieu de racket fait aussi une grande différence. Plus de détails ici : https://docs.racket-lang.org/style/Language_and_Performance....
      Le fait de ne pas démarrer dans un « état propre » ressemble davantage à un REPL à la Common Lisp qu’à Racket. Avec Racket, il faut généralement redémarrer Racket quand on recharge un fichier ou un module, ce qui donne un environnement frais. Les gens s’en plaignent, mais je préfère l’approche à état propre de Racket à celle de CL
    • La partie sur le fait de ne pas démarrer dans un « état propre » semble, d’après la documentation, laisser l’utilisateur refuser explicitement l’enregistrement de fichiers de sauvegarde
      https://docs.racket-lang.org/drracket/drracket-files.html#(p...
      Il est probablement aussi possible de refuser la proposition de restauration
      « Au premier démarrage, DrRacket vérifie s’il reste des fichiers de sauvegarde et, le cas échéant, propose de les restaurer »
    • Il suffit d’essayer Smalltalk :-))
    • Guile pourrait être intéressant. Surtout pour le débogage, je le trouve plus immersif que Racket, et aussi plus proche de Common Lisp (SBCL)
    • Bienvenue dans le monde de Smalltalk et des Lisp Machines. Même les IDE modernes ne prennent pas encore correctement en charge tout à la fois : hot reload, sauvegarde de l’état de travail et contrôle de toute la stack de développement dans un seul langage

  • Quand j’étudiais à l’University of British Columbia, Racket était enseigné dans le cours d’introduction à l’informatique. Je trouvais que c’était un excellent langage, et comme même les étudiants ayant déjà une expérience de programmation avaient rarement fait du Lisp, cela mettait tout le monde sur la même ligne de départ
    J’avais aussi été impressionné par les bibliothèques qui permettaient de créer facilement de petits jeux ou des visualisations

    • J’ai aussi suivi ce cours à l’UBC, mais j’en ai gardé une impression complètement différente. C’était affreux, et je pense que cela préparait très mal les débutants aux cours suivants de structures de données et d’algorithmes, enseignés dans des langages impératifs
      Quand j’étais assistant d’enseignement, beaucoup d’étudiants arrivant en deuxième année ne savaient toujours pas faire une boucle for, et avaient un gros retard sur les algorithmes de base
      Je n’ai développé une appréciation plus profonde des langages fonctionnels qu’après le cours de théorie du calcul en quatrième année

  • Je ne vois pas comment intégrer tous ces « langages » de Racket dans une seule application. Je vois des langages comme typed/racket, racket/gui, scribble/base, mais je n’ai aucune idée de la façon de créer une application GUI avec du code typé tout en générant aussi des PDF
    J’ai suivi plusieurs fois les tutoriels Racket, mais je reste perdu sur la manière d’assembler ces « langages » qui semblent sans rapport
    Personnellement, j’ai l’impression que chaque chapitre du tutoriel n’explique qu’un « langage » sans lien avec les autres, sans jamais montrer comment ils fonctionnent ensemble. Un chapitre traite d’un serveur web mais pas du système de classes ; un autre traite d’un autre « langage » qui prend en charge les classes, mais sans y écrire de serveur web

    • On peut voir la ligne #lang comme une sorte de directive de compilation limitée à ce fichier. En réalité, il y a beaucoup plus que ça, mais c’est un bon point de départ. Si vous voulez ajouter des types à une application, la bonne stratégie consiste à le faire fichier par fichier
      En plus de la ligne #lang, on peut importer des bibliothèques avec require, donc on peut aussi mettre du code GUI et du code de serveur web dans un même fichier. #lang n’est pas non plus limité à un seul langage à la fois : on peut en ajouter davantage sur cette ligne tant qu’il n’y a pas de conflit
    • Je trouve que c’est une question légitime. Si vous développez une grosse application, il est probable que presque tout votre code soit écrit dans le langage "racket". Si les types vous intéressent beaucoup, une bonne partie pourrait être en "typed/racket"
      Il est vrai que tous les langages partagent une base commune et interopèrent dans une certaine mesure, mais il est très peu probable que vous découpiez un programme en cinq morceaux égaux, chacun écrit dans un langage différent. La documentation sera probablement écrite en scribble
      Utiliser des langages différents peut donner des modèles de programmation fondamentalement différents, et c’est aussi ce qui a rendu possible le développement de choses comme Typed Racket, mais cela ne devrait pas être un obstacle pour commencer
      En résumé, utilisez simplement Racket. Si vous sentez vraiment qu’il vous faut une autre fonctionnalité ou un autre style de programmation, cherchez alors s’il existe déjà un langage qui le fournit. Bien sûr, ce n’est que mon avis
    • Pour autant que je sache, chaque module permet de choisir le langage de ce module

  • Ce site web, Hacker News, est écrit en Arc et tourne sur Racket : https://en.wikipedia.org/wiki/Arc_(programming_language)

  • Le plus gros problème de Racket n’est ni le langage ni son écosystème : https://news.ycombinator.com/item?id=27531508

    • J’étais étudiant à la Racket School 2018 mentionnée dans le lien. Tous les enseignants, dont Felleisen et Butterick, ont été vraiment serviables et bienveillants, en cours comme en dehors.
      Même en prenant ce lien entièrement au pied de la lettre et en admettant que Felleisen se comporte, dans certaines interactions personnelles, de façon désagréable à la Torvalds, son travail, y compris How To Design Programs, a eu un impact très positif sur ma vie et celle d’autres personnes. Je ne dirais donc pas aux gens de ne pas s’en servir.
    • Il s’agit d’un conflit très personnel entre des membres connus de la communauté. La communauté Racket au sens large, y compris l’équipe cœur, est très accueillante.
    • Felleisen est quelqu’un de difficile à supporter, mais aussi facile à éviter. Je vois cela plutôt comme un symptôme des travers du monde universitaire que comme un problème propre à Racket.
      La communauté compte aussi des « nerds bizarres » aux opinions tranchées, ce qui peut leur donner une présence plus visible et donc les rendre plus agaçants. Mais comme dans beaucoup d’espaces sociaux où l’argent ne maintient pas l’ordre, c’est comme ça.

  • Racket est mon langage préféré. Il est rapide, pratique, repose sur des bases solides et possède aussi un très bon modèle de concurrence. Il s’appuie sur des idées empruntées à Concurrent ML et étendues.
    Le système de documentation est également excellent et intégré à l’écosystème de paquets, si bien que la plupart des paquets disposent d’une documentation de grande qualité avec des références croisées. La rétrocompatibilité est elle aussi excellente, bien meilleure selon moi que celle de Python, que j’utilise actuellement dans mon travail principal.
    Du coup, j’ai l’impression que les gens qui disent que Racket est trop académique ou pas assez pratique ne l’ont pas exploré assez en profondeur, ou bien qu’il s’agit d’anciens étudiants qui n’ont connu que les langages pédagogiques.
    Bien sûr, il n’est pas parfait. La communauté est petite, l’empreinte mémoire de base du runtime est élevée, et pour faire du parallélisme il faut lancer une VM Racket par thread système, entre autres problèmes. Mais ces points devraient s’améliorer avec le temps.
    Ce que j’ai construit avec Racket ces dernières années : un site d’e-commerce[1], une application native de rappels macOS/iOS publiée sur l’App Store[2, 3, 4], un client desktop multiplateforme pour Apache Kafka[5, 6, 7], un #lang pour Lua[8]. Il y a aussi plusieurs autres choses[9][10][11]. Je pense que ce sont des réalisations assez pratiques.
    [1]: https://defn.io/2019/08/20/racket-ecommerce/
    [2]: https://defn.io/2020/01/02/ann-remember/
    [3]: https://defn.io/2024/04/09/ann-remember-for-ios/
    [4]: https://github.com/bogdanp/remember
    [5]: https://defn.io/2022/11/20/ann-franz/
    [6]: https://defn.io/2023/10/15/ann-franz-for-windows/
    [7]: https://defn.io/2023/08/10/ann-franz-source-available/
    [8]: https://defn.io/2022/11/12/ann-racket-lua/
    [9]: https://docs.racket-lang.org/http-easy/index.html
    [10]: https://docs.racket-lang.org/deta/index.html
    [11]: https://docs.racket-lang.org/gui-easy/index.html

    • Bogdan est aussi l’auteur de gui-easy et http-easy, indispensables dans l’écosystème Racket.
      Il est aussi très actif sur le forum de la communauté et y donne énormément de réponses utiles.
      Je voulais absolument le mentionner, car je le considère comme un héros méconnu de ce langage. On peut dire que vos bibliothèques font tourner du code qui rend la vie d’utilisateurs parfaitement ignorants bien plus facile :)
      https://docs.racket-lang.org/http-easy/index.html
      https://docs.racket-lang.org/gui-easy/index.html
      https://racket.discourse.group
    • La rétrocompatibilité est, à mon avis, un point vraiment essentiel. J’ai utilisé Python de façon intensive pendant des années, mais la transition 2/3 m’a profondément déçu en montrant à quel point les développeurs principaux et la communauté se souciaient peu de la rétrocompatibilité, et cela ne s’est pas amélioré depuis.
      C’est peut-être lié aux domaines dans lesquels Python est surtout utilisé aujourd’hui. La transition Numeric/Numpy autour de 2000 était complètement différente.
      Casser des choses tous les quelques années peut convenir à des startups licornes ou à des entreprises qui avancent vite et, littéralement, cassent des choses. Mais il existe beaucoup de programmes qui ont de la valeur pour des personnes et des organisations qui n’ont pas les moyens de réécrire des algorithmes matures tous les quelques années, ou qui ne considèrent pas cela comme une priorité.

  • J’utilise Racket de temps en temps et je l’apprécie. Cela dit, j’ai fini par comprendre que certains Lisp, en particulier Common Lisp, et probablement Guile aussi, sont plus sous-estimés qu’on ne le pense
    J’aimerais poser la question à des personnes qui s’y connaissent mieux : quelles fonctionnalités de Racket ne semblent pas pratiques, pertinentes ou utiles au premier abord, mais se révèlent étonnamment utiles pour programmer une fois qu’on les essaie ?

  • Il y a environ 20 ans, avant que MzScheme ne devienne PLT Scheme, j’ai travaillé sur un logiciel commercial de sécurité des e-mails qui l’utilisait comme langage de base. Le code était multiplateforme et fonctionnait sous Solaris, Linux et HP-UX ; le code propre à chaque système d’exploitation représentait environ un millier de lignes en C
    Les règles de filtrage étaient compilées directement en Scheme. En incluant même l’interface web, l’ensemble du code faisait environ 30 000 lignes, et il n’y avait que 5 ou 6 développeurs
    Plus tard, après avoir émigré, j’ai rejoint une entreprise qui proposait un produit similaire, mais avec moins de fonctionnalités ; ce produit comptait des centaines de milliers de lignes en C++ et davantage de développeurs