Lua est un langage sous-estimé

(nflatrea.bearblog.dev)

10 points par GN⁺ 2024-12-28 | 7 commentaires | Partager sur WhatsApp

Plus j’en apprends sur la conception et l’implémentation de Lua, plus je suis impressionné. Il est rare de voir un logiciel accomplir autant avec si peu de code
Cependant, Lua n’a pas bénéficié d’autant de marketing ni d’attention que d’autres langages. En conséquence, peu de développeurs connaissent réellement ses fonctionnalités et ses avantages
Il est surtout perçu comme un langage de niche utilisé dans les jeux et les systèmes embarqués

[Caractéristiques et avantages de Lua]

Un langage facile à comprendre

Lua est un langage de script gratuit, réflexif et impératif. Il a été créé en 1993 et conçu pour être intégré à d’autres applications afin de les étendre.
Sa conception est élégante et son code est rapide. L’API C est facile à utiliser et offre de bonnes performances.
Sa syntaxe est concise et minimaliste, ce qui le rend accessible même aux débutants.

Excellente capacité d’intégration

Lua a été conçu pour être facilement embarqué dans des applications écrites dans d’autres langages, en particulier en C et C++.
C’est un excellent choix pour le scripting et l’extension de jeux et d’applications embarquées.

Exemple : intégrer Lua dans un programme C

#include &lt;lua.h&gt;  
#include &lt;lauxlib.h&gt;  
#include &lt;lualib.h&gt;  

int main() {  
    lua_State *L = luaL_newstate();  
    luaL_openlibs(L);  
    luaL_dofile(L, &quot;./myscript.lua&quot;);  
    lua_close(L);  
    return 0;  
}

Prise en charge de plusieurs paradigmes de programmation

Lua prend en charge la programmation impérative, fonctionnelle et orientée objet, seul ou avec les bibliothèques appropriées.
Il offre la flexibilité de choisir le style de programmation adapté à ses besoins

[Inconvénients potentiels de Lua]

Convention d’indexation

En Lua, l’indexation commence généralement à 1, mais ce n’est qu’une convention. Les tableaux peuvent être indexés à partir de 0, de valeurs négatives ou d’autres valeurs.
En réalité, Lua n’a pas de vrais tableaux : il n’existe que des tables, qui sont toujours des hachages clé-valeur, et peuvent donc être indexées par 0, des valeurs négatives ou diverses autres valeurs
La bibliothèque standard et les fonctions intégrées supposent des tables de type tableau dont les indices commencent à 1.

Gestion des erreurs

La gestion des erreurs de Lua peut sembler peu intuitive pour des développeurs venant d’autres langages.

Dans Lua, les erreurs peuvent être traitées comme des valeurs. On peut les intercepter avec pcall.

function risky_function()  
    error(&quot;Something went wrong!&quot;)  
end  

local status, err = pcall(risky_function)  
if not status then  
    print(&quot;Error: &quot; .. err)  
end

Tableaux terminés par `nil`

Les tableaux Lua (c’est-à-dire les tables utilisées comme tableaux) s’arrêtent lorsqu’ils rencontrent une valeur nil, ce qui peut provoquer des comportements inattendus
```
local arr = {10, 20, 30, nil, 50}  
for i, v in ipairs(arr) do  
    print(v) -- sortie : 10, 20, 30 (arrêt sur nil)  
end  
```
La fonction ipairs arrête l’itération dès qu’elle rencontre une valeur nil
S’il y a des trous dans un tableau, il est préférable d’utiliser pairs plutôt que ipairs. Cela permet de parcourir tous les éléments, y compris en présence de valeurs nil

[Résumé]

Lua est un langage de programmation puissant, efficace et polyvalent qui mérite bien plus de reconnaissance.
Grâce à sa simplicité, sa capacité d’intégration et ses performances, il convient à des applications variées comme les jeux et les systèmes embarqués.
Bien que sous-estimé, il vaut la peine d’être essayé pour sa simplicité et ses performances
Il est utilisé dans le système de plugins de nvim et s’y montre efficace.

7 commentaires

jhj0517 2025-01-03

> En réalité, Lua n’a pas de tableaux ; il n’existe que des tables, qui sont toujours des hashmaps clé-valeur, et on peut donc les indexer avec toutes sortes de valeurs comme 0 ou des nombres négatifs

J’ai utilisé Lua brièvement à cause des addons de WoW, et je me souviens que c’est cet aspect qui m’avait le plus marqué. Ils utilisaient des tables pour presque toutes les structures de données.

asdwqr 2024-12-31

Je ne connaissais que le nom de Lua, mais en voyant cet article, j’en suis venu à penser que ce n’était pas terrible, haha...

bbulbum 2024-12-30

Je ne m’y connais pas très bien, mais j’ai entendu dire que la rétrocompatibilité entre les versions était terrible..

ffdd270 2024-12-30

Personnellement, comparé à Ruby, c’est peut-être un peu meilleur quand la question est simplement « est-ce que l’ancien code tourne encore ?? », mais surtout à partir de la 5.3, la façon de gérer les number a changé par rapport aux versions précédentes, donc quand on passe de la 5.1 à la 5.3, ça crée plein de bugs difficiles à suivre en interne...

Et il y a aussi beaucoup d’endroits qui utilisent LuaJIT, et comme l’interface y est encore légèrement différente, j’ai l’impression que les problèmes causés par ces petites différences sont les plus graves. Il y a pas mal de parties dont le fonctionnement interne a changé, donc on ne peut pas vraiment y faire grand-chose.. =m =.

secret3056 2024-12-30

J’ai eu l’expérience d’écrire des drivers Edge pour SmartThings en Lua.
C’était globalement utilisable, mais ce n’était pas un langage à mon goût.

Pour moi, l’environnement de développement ou l’IDE fait aussi partie du langage,
et j’ai d’abord l’impression qu’il y a une certaine fragmentation de la communauté.

Il existe aussi plusieurs language servers, mais il leur manque chacun certaines fonctionnalités, ou bien l’indexation du code est lente et, dès qu’il y a une modification, ils repartent de zéro.

L’indexation à partir de 1 ou le fait d’écrire des indications de type dans les commentaires ne me plaisent pas non plus,
et ces indications de type ne semblaient pas non plus standardisées, chaque language server ayant apparemment son propre format.

Les coroutines me rappellent aussi celles du vieux Python...

En revanche, l’embarqué et le FFI semblent effectivement assez pratiques.

ffdd270 2024-12-30

Ces temps-ci, le serveur de langage Lua créé par sumneko est une tuerie `'m '... (je crois qu’il l’a fait en 2022 ou 2023). Son indexation est vraiment assez bien pensée.

Je pense que le principal avantage de Lua — et aussi son principal défaut — apparaît surtout quand on commence à faire des choses bizarres : il est ridiculement facile d’écraser les méthodes d’autres objets. Du coup, je trouve que c’est un langage vraiment idéal pour écrire un peu à l’arrache, au fil des idées.

Pour le type hinting... comme vous l’avez dit, il existe énormément de solutions proposées, mais presque aucune ne s’est vraiment imposée, donc je place pas mal d’espoir dans Luau, créé par l’équipe de Roblox..

GN⁺ 2024-12-28

Avis Hacker News

Lua est bien adapté à l’embarqué, mais le choix de Redis d’en faire son langage de script a suscité beaucoup de regrets. Je n’aime pas le langage en lui-même. Il semble y avoir une friction entre ce qu’on attend de son niveau d’abstraction et ce qu’il offre réellement. Une accumulation de petits choix de conception le rend assez hostile. Cela dit, il reste intéressant grâce à sa rapidité, sa facilité d’intégration, sa faible empreinte mémoire et sa fiabilité. Même au niveau de la C-API, il y a cette même hostilité à cause de l’approche par pile. J’ai déjà été exposé à des langages à pile comme FORTH, mais écrire des bindings demandait quand même un effort mental.
Si vous aimez Lua, je recommande de regarder Terra. Terra est un langage de programmation système bas niveau embarqué dans Lua et piloté par métaprogrammation. C’est un langage compilé et statiquement typé, comme le C/C++, avec gestion manuelle de la mémoire. Mais contrairement au C/C++, il a été conçu dès le départ pour être métaprogrammé avec Lua. Les programmes Terra utilisent le même backend LLVM que le compilateur C d’Apple. Cela signifie que le code Terra offre des performances comparables à du code C équivalent.
J’ai récemment intégré Lua à un moteur de jeu custom, et je comprends à quel point son intégration avec d’autres langages peut être propre. L’interface est nette, ce qui facilite la génération automatique de bindings. J’ai utilisé les Roslyn Incremental Source Generators pour générer automatiquement les bindings entre C# et Lua, et grâce à la conception de l’interface, ce n’était pas du tout difficile. La pile Lua, le typage dynamique et les « tables » rendaient aussi simple la génération de marshalleurs pour des classes de données arbitraires entre C# et Lua. Cela dit, il y a aussi beaucoup de critiques valables à faire sur le langage lui-même. En particulier, je n’aime pas l’indexation à partir de 1. Je réfléchis à concevoir un langage de script embarqué avec une interface similaire tout en corrigeant ces problèmes.
Je n’ai pas développé plus d’affection pour Lua. Au contraire, mes frustrations se sont renforcées. Cela fait longtemps que je n’ai pas écrit de Lua, mais je l’ai toujours trouvé peu intuitif. Je ne comprends pas pourquoi les tableaux sont des tables, pourquoi ils se terminent avec nil ni pourquoi ils commencent à 1. Je ne pense pas que Lua soit sous-estimé. Il est très populaire pour écrire des scripts dans les moteurs de jeu (anciens).
J’ai créé un chatbot avec des commandes de plugin Lua, mais l’intégrer dans un programme C++ a été une expérience épouvantable. Je ne comprends pas pourquoi les gens disent que l’embarquer est facile. Il faut énormément manipuler la pile. Le langage lui-même est pénible et n’aide absolument pas quand on fait une erreur. Je n’utiliserai plus jamais Lua et j’éviterai les projets qui l’utilisent.
Lua rend difficile l’écriture d’une quantité importante de code à cause de son typage faible, de l’absence d’indications de type et de gestion des erreurs. Il n’est pas sous-estimé. Avec le temps, j’en suis venu à préférer de plus en plus les langages à typage statique et les indications de type (Python, TypeScript). Écrire du code Python ou JS sans annotations dans une communauté est néfaste. J’ai récemment réécrit 1,5k cloc de JS en TypeScript. Il y avait toujours des dizaines de null manquants, d’accès à des propriétés de null ou de null sémantiquement suspects.
Je pense que la plupart des applications qui ont besoin de scripting devraient embarquer JavaScript. L’écosystème existant apporte un énorme avantage. Tout le monde n’aime pas forcément ça, mais des millions de personnes le connaissent déjà. Il n’y a pas besoin de réapprendre les bizarreries de l’indexation des tableaux, de la terminaison par nil et des dizaines d’autres choses que Lua ne révèle qu’à l’exécution. Il existe des moteurs JS de toutes tailles, et la plupart des systèmes d’exploitation fournissent des moteurs de haute qualité et des frameworks d’embarqué accessibles sans installation. Mieux vaut utiliser un langage standard plutôt que forcer les utilisateurs à en apprendre un nouveau. Cela peut faire gagner du temps à la fois aux utilisateurs et à vous-même.
J’ai aimé travailler avec Lua et je pense que c’est un très bon langage. En particulier, son interface d’embarqué dans C/C++ est propre et souple. Il y a des problèmes de performance, mais vu l’usage répandu de Lua pour la logique de jeu dans des jeux vidéo à hautes performances, ces problèmes semblent surmontables. En revanche, il y a d’autres problèmes qui le rendent déroutant et compliquent le langage. Comme apprendre l’interface entre Lua et C représente presque autant de travail qu’apprendre Lua lui-même, passer d’un déploiement à un autre est plus confus qu’avec d’autres langages. Malgré tout, je pense que le langage est sous-estimé.
Intégrer Lua était amusant, mais comme avec wasm, j’ai rarement eu besoin d’exécuter du nouveau code sans recompiler tout le binaire. Le plus amusant a été de créer un moteur de jeu en C++ et d’utiliser Lua pour toute la logique du jeu. Le cycle de debug rapide était extrêmement utile. La deuxième expérience la plus amusante a été de créer un bot IRC capable de recharger sa logique Lua. La troisième a été d’utiliser Lua comme langage de configuration Turing-complet. Quand j’avais besoin de tableaux, je les fabriquais en Lua. Ce qui a été le moins amusant, c’était un plugin Blender qui exportait des modèles 3D en Lua généré.
Je pense que Lua est surévalué, parce qu’il est largement utilisé dans l’industrie du jeu vidéo. Le seul avantage de Lua, c’est qu’il s’embarque facilement dans du C++. À part ça, c’est un cauchemar.