Lua a fondo: tablas y metatablas, closures y upvalues, corrutinas, el recolector y la máquina virtual de registros, la API C, embeber el lenguaje y LuaJIT.
Cada nivel construye sobre el anterior. Sin saltos, sin huecos.
La visión aérea: un lenguaje diminuto construido sobre tablas y closures, su máquina virtual de registros, la API C que lo hace embebible, y dónde vive hoy.
De dónde sale Lua, la obsesión por el tamaño y la portabilidad, y por qué acabó dentro de juegos, de nginx, de Redis y de tu editor.
Los tipos de Lua, la ausencia de declaraciones, `nil` frente a `false`, la verdad en Lua, y la diferencia entre valor e identidad.
La división de números desde 5.3: subtipo entero y flotante, aritmética, división entera, conversiones implícitas y desbordamiento.
Las cadenas por dentro: inmutabilidad, internamiento de cadenas cortas, escapes, cadenas largas, y las cadenas externas de 5.5.
La tabla como array, diccionario, objeto, módulo y espacio de nombres a la vez; constructores, claves, y el idioma de la tabla vacía.
La representación real: parte array y parte hash, el rehash y su coste, los arrays compactos de 5.5, y por qué el operador de longitud es traicionero.
Funciones como valores, retornos múltiples y sus reglas de ajuste, `...` y los varargs, y las tablas de varargs con nombre de 5.5.
Qué captura exactamente un closure: upvalues abiertos y cerrados, closures que comparten estado, y por qué esto define el estilo de Lua.
Locales frente a globales, el coste de un global, `_ENV` como upvalue implícito, entornos personalizados, y las declaraciones de globales de 5.5.
El mecanismo que hace flexible a Lua: metatablas y metamétodos, `__index` con tabla y con función, `__newindex`, y las tablas de solo lectura.
Operadores aritméticos y de comparación, `__call`, `__tostring`, `__len`, `__gc`, y las variables to-be-closed con `__close`.
La orientación a objetos que no viene de fábrica: el idioma de la clase, `self` y los dos puntos, herencia, y las alternativas sin metatablas.
Cómo carga Lua un módulo: `package.path` y `package.cpath`, los searchers, el caché de `package.loaded`, y escribir un módulo bien.
El modelo de errores sin excepciones: `error` y sus niveles, `pcall` y `xpcall`, tracebacks, y el idioma de devolver `nil` con un mensaje.
Corrutinas de verdad: `create`, `resume`, `yield` y el paso de valores en ambos sentidos; su estado, y en qué se diferencian de los hilos.
Lo que se puede edificar encima: generadores, productores y consumidores, y cómo se implementa async sobre corrutinas en bibliotecas reales.
El `for` genérico por dentro: la tripleta de función, estado y control; iteradores con y sin estado, y escribir los tuyos.
Todo lo que trae Lua: `string`, `table`, `math`, `os`, `io`, `utf8`; qué falta deliberadamente y por qué no hay batteries included.
El lenguaje de patrones propio de Lua: clases, cuantificadores, capturas, anclas, `gsub` y `gmatch`, y sus límites frente a una regex.
`load` y la compilación en tiempo de ejecución, funciones como datos, generar Lua desde Lua, y los riesgos de hacerlo.
La gestión de memoria: marcado y barrido incremental, el modo generacional, los cambios de 5.5, tablas débiles y finalizadores.
Empieza por los fundamentos y sube nivel a nivel hasta el dominio total.
Comenzar el camino →