Lua es un lenguaje subestimado

(nflatrea.bearblog.dev)

10 puntos por GN⁺ 2024-12-28 | 7 comentarios | Compartir por WhatsApp

Cuanto más aprendo sobre el diseño y la implementación de Lua, más me impresiona. Es raro encontrar software que haga tanto con tan poco código.
Sin embargo, Lua no ha recibido el mismo marketing ni la misma atención que otros lenguajes. Por eso, pocos desarrolladores conocen sus capacidades y ventajas.
Suele percibirse como un lenguaje de nicho usado principalmente en videojuegos y sistemas embebidos.

[Características y ventajas de Lua]

Un lenguaje fácil de entender

Lua es un lenguaje de scripting gratuito, reflexivo e imperativo. Fue creado en 1993 y diseñado para poder incrustarse en otras aplicaciones y extenderlas.
Su diseño es limpio y su código es rápido. La API de C es fácil de usar y ofrece buen rendimiento.
Su sintaxis es concisa y minimalista, así que incluso para principiantes es fácil de abordar.

Excelente capacidad de embebido

Lua fue diseñado para incrustarse fácilmente en aplicaciones escritas en otros lenguajes, especialmente C y C++.
Es una opción sobresaliente para scripting y extensiones en videojuegos y aplicaciones embebidas.

Ejemplo: incrustar Lua en un programa en 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;  
}

Soporte para múltiples paradigmas de programación

Lua soporta programación imperativa, funcional y orientada a objetos, ya sea por sí sola o junto con bibliotecas adecuadas.
Ofrece la flexibilidad de elegir el estilo de programación que mejor se adapte a las necesidades del usuario.

[Posibles desventajas de Lua]

Convención de indexación

En Lua, la indexación normalmente comienza en 1, pero eso es una convención. Los arreglos pueden indexarse con 0, números negativos u otros valores.
En realidad, Lua no tiene arreglos como tal; solo existen tablas, que siempre son hashes clave-valor, por lo que pueden indexarse con 0, negativos u otros valores.
La biblioteca estándar y las funciones integradas asumen tablas tipo arreglo cuyos índices comienzan en 1.

Manejo de errores

El manejo de errores de Lua puede no resultar intuitivo para desarrolladores que vienen de otros lenguajes.

En Lua, los errores pueden tratarse como valores. Se puede usar pcall para capturarlos.

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

Arreglos terminados por nil

Los arreglos de Lua (tablas usadas como arreglos) terminan al encontrar un valor nil, lo que puede provocar comportamientos inesperados.
```
local arr = {10, 20, 30, nil, 50}  
for i, v in ipairs(arr) do  
    print(v) -- salida: 10, 20, 30 (se detiene en nil)  
end  
```
La función ipairs detiene la iteración al encontrar un valor nil.
Si hay huecos en el arreglo, conviene usar pairs en lugar de ipairs. Así se pueden recorrer todos los elementos, incluidos los que rodean valores nil.

[Resumen]

Lua es un lenguaje de programación potente, eficiente y versátil que merece mucho más reconocimiento.
Gracias a su simplicidad, capacidad de embebido y rendimiento, es adecuado para diversas aplicaciones como videojuegos y sistemas embebidos.
Aunque está subestimado, vale la pena probarlo por su simplicidad y rendimiento.
Se usa en el sistema de plugins de nvim y es eficiente.

7 comentarios

jhj0517 2025-01-03

> En realidad, Lua no tiene arreglos; solo existen tablas, que siempre son hashes de clave-valor, así que se puede indexar con distintos valores como 0 o números negativos.

Probé Lua por un tiempo por los addons de WoW, y recuerdo que esa fue la parte que más me impresionó. Usaban tablas para casi todas las estructuras de datos.

asdwqr 2024-12-31

Solo conocía el nombre de Lua, pero después de ver este artículo me hizo pensar que no era la gran cosa jajaja..

bbulbum 2024-12-30

No lo sé bien, pero escuché que la compatibilidad con versiones anteriores es terrible..

ffdd270 2024-12-30

Personalmente, comparado con Ruby..., para la pregunta de "¿al menos corre el código viejo??" diría que está un poco mejor, pero en especial en 5.3 cambió la forma de tratar los number respecto a versiones anteriores, así que si subes de 5.1 a 5.3 aparecen montones de bugs que internamente son difíciles de rastrear...

Y también hay muchos lugares que usan LuaJIT, y ahí la interfaz vuelve a ser sutilmente distinta, así que creo que los problemas que surgen por esas pequeñas diferencias son los más graves. Hay bastantes partes donde el funcionamiento interno cambió, así que tampoco hay mucho que se pueda hacer... =m =.

secret3056 2024-12-30

Tengo experiencia escribiendo drivers Edge de SmartThings en Lua.
Más o menos se podía usar, pero no era un lenguaje de mi gusto.

Yo considero que el entorno de desarrollo y el DE también son parte del lenguaje,
y para empezar, me parece que la comunidad está algo fragmentada.

También hay varios language server, pero a cada uno le falta alguna función, o el indexado de código es lento y, cuando hay cambios, vuelven a empezar desde cero.

Tampoco me convencen el indexado base 1 ni tener que escribir pistas de tipos en comentarios,
y además esas pistas de tipos no parecen tener un estándar, sino que varían según el language server.

Las corrutinas también me recuerdan a las del Python viejo...

Eso sí, el embedding y el FFI sí parecen bastante prácticos.

ffdd270 2024-12-30

Últimamente, el servidor de lenguaje para Lua que hizo sumneko está brutal 'ㅁ '... (lo hicieron en 2022 o 2023). El indexado de este sí que me pareció bastante bien pensado.

Creo que la ventaja de Lua (y también su desventaja) aparece cuando te pones a hacer cosas raras: es absurdamente fácil sobrescribir métodos de otros objetos. Por eso, me parece un lenguaje muy bueno para usar de forma medio caótica, escribiendo lo que se te va ocurriendo.

El type hinting... como dijiste, sí han salido muchísimas soluciones, pero casi ninguna se ha asentado de verdad, así que tengo esperanzas puestas en Luau, que hizo el equipo de Roblox..

GN⁺ 2024-12-28

Comentario de Hacker News

Lua es bueno para embebido, pero hubo mucho arrepentimiento por haberlo elegido como lenguaje de scripting en Redis. El lenguaje en sí no me gusta. Parece haber fricción frente a lo que uno espera de su nivel de abstracción. Pequeñas decisiones de diseño se acumulan y hacen que el lenguaje sea algo hostil. Aun así, sigue valiendo la pena elegirlo por ser rápido, fácil de integrar, con bajo uso de memoria y confiable. Incluso a nivel de la C-API hay cierta hostilidad por el enfoque de acceso mediante pila. He estado expuesto a lenguajes de pila como FORTH, pero aun así escribir bindings requería gimnasia mental.
Si te gusta Lua, recomiendo ver Terra. Terra es un lenguaje de programación de sistemas de bajo nivel embebido en Lua y metaprogramado desde Lua. Es un lenguaje compilado y de tipos estáticos, como C/C++, y permite gestión manual de memoria. Pero, a diferencia de C/C++, fue diseñado desde el inicio para ser metaprogramado con Lua. Los programas en Terra usan el mismo backend de LLVM que usa el compilador de C de Apple. Eso significa que el código de Terra ofrece un rendimiento similar al de código C equivalente.
Hace poco trabajé integrando Lua con un motor de juego personalizado, y coincido en lo limpia que es su integración con otros lenguajes. La interfaz es limpia, así que es fácil generar bindings automáticamente. Usé Roslyn Incremental Source Generators para generar automáticamente bindings entre C# y Lua, y gracias al diseño de la interfaz no fue nada difícil. La pila de Lua, el tipado dinámico y las "tablas" hicieron fácil generar marshalers para clases de datos arbitrarias entre C# y Lua. Pero también hay muchas críticas válidas al lenguaje en sí. En particular, no me gusta la indexación basada en 1. Estoy considerando diseñar un lenguaje de scripting embebido con una interfaz similar, pero resolviendo estos problemas.
No le he agarrado más cariño a Lua. Más bien, mis quejas se reforzaron. Hace mucho que no escribo Lua, pero siempre me pareció poco intuitivo. No entiendo por qué los arreglos son tablas, por qué terminan con nil y por qué empiezan en 1. No creo que Lua esté subestimado. Es muy popular para escribir scripts en motores de juego (antiguos).
Hice un chatbot con comandos de plugin en Lua, pero tuve una experiencia terrible integrándolo en un programa en C++. No entiendo por qué la gente dice que es fácil de embeber. Hay que manipular mucho la pila. El lenguaje en sí es engorroso y no ayuda en absoluto cuando cometes errores. No volveré a usar Lua y evitaré proyectos que usen Lua.
Lua dificulta escribir una cantidad considerable de código por su tipado débil, la ausencia de type hints y la falta de manejo de errores. No está subestimado. Con el tiempo me han ido gustando cada vez más los lenguajes estáticos y los type hints (Python, TypeScript). Es perjudicial para la comunidad escribir código Python o JS sin hints. Hace poco reescribí 1.5k cloc de JS a TypeScript. Siempre había decenas de null faltantes, accesos a propiedades de null o null semánticamente sospechosos.
Creo que la mayoría de las aplicaciones que necesitan scripting deberían embeber JavaScript. Hay una gran ventaja en el ecosistema existente. A la gente no siempre le gusta, pero millones ya lo conocen. No hace falta reaprender las rarezas de la indexación de arreglos y la terminación con nil, junto con decenas de otras cosas que Lua te hace descubrir en tiempo de ejecución. Hay motores de JS de todos los tamaños, y la mayoría de los sistemas operativos ofrecen motores de alta calidad y frameworks de embebido accesibles sin instalación. En vez de hacer que los usuarios aprendan un lenguaje nuevo, es mejor usar un lenguaje estándar. Puede ahorrarles tiempo tanto a los usuarios como a uno mismo.
Disfruté trabajar con Lua y creo que es un lenguaje muy bueno. En especial, su interfaz para embebido en C/C++ es limpia y flexible. Hay problemas de rendimiento, pero considerando que Lua se usa ampliamente para la lógica de juego en videojuegos de alto rendimiento, esos problemas parecen resolubles. Sin embargo, hay otros problemas que confunden y vuelven difícil el lenguaje. Aprender la interfaz entre Lua y C es casi tanto como aprender Lua mismo, así que cambiar entre distribuciones resulta más confuso que con otros lenguajes. Aun así, creo que el lenguaje está subestimado.
Embeber Lua fue divertido, pero al igual que con wasm, casi nunca necesité ejecutar código nuevo sin recompilar todo el binario. Lo más divertido fue crear un motor de juego en C++ y usar Lua para toda la lógica del juego. El ciclo rápido de depuración fue muy útil. Lo segundo más divertido fue hacer un bot de IRC capaz de recargar la lógica en Lua. Lo tercero más divertido fue usar Lua como un lenguaje de configuración Turing completo. Cuando necesitaba arreglos, los hacía en Lua. Lo menos divertido fue un plugin de Blender que exportaba modelos 3D a Lua generado.
Creo que Lua está sobrevalorado, porque se usa mucho en la industria de los videojuegos. La única ventaja de Lua es que se puede embeber fácilmente en C++. Fuera de eso, es una pesadilla.