lua

Seems similar in impact to https://nvd.nist.gov/vuln/detail/cve-2021-32626, I wonder why this has a CVE 10. This code also looks generally fixed in Lua5.4, https://github.com/lua/lua/blame/9ea06e61f20ae34974226074fc6.... Valkey and Redis really need to move to Lua that isn't so old.

This optimization might land in the next Lua release. More specifically, the "Reflected Arrays" version (Figure 6). https://github.com/lua/lua/blob/f71156744851701b5d5fabdda506...

One of the performance improvements mentioned is "Remove the usage of the C stack in Python to Python calls" [0]. Since Python 3.11, a Python-level function call can be evaluated within the bytecode interpreter loop, no longer requiring a C-level function call. Interestingly, Lua 5.4 did the opposite. Its implementation introduced C-level function calls for performance reasons [1] (although this change was reverted in 5.4.2 [2]). [0] https://bugs.python.org/issue45256 [1] https://github.com/lua/lua/commit/196c87c9cecfacf978f37de4ec... [1] https://github.com/lua/lua/commit/5d8ce05b3f6fad79e37ed21c10...

It’s Portuguese. It’s the same in the Lua codebase [1]. [1]: https://github.com/lua/lua

Some code. E.g. most of my code was barely read by anyone, as most of it was utilitary or mvp or niche/local enough to never see big light. And when from time to time I read other code, e.g. on github, in projects I’m occasionally interested in, there’s barely anything resembling these high class advices. FOSS with large reach - yeah. But a library that you found for a specific hardware is “just code”. And to be honest, the difference between the two is not that big. Any decent programmer navigates both almost equally fast. As someone who modified Lua internals (typical example [1]) for employer’s needs I can say that I prefer Lua style to ceremony on top of ceremony, to multiparagraph explanations of what should be obvious to a competent developer, and to hundreds of extracted functions for the sole reason of clean-ish scopes or whatever

Literally any header file in https://github.com/lua/lua In particular, https://github.com/lua/lua/blob/master/ldo.h

https://github.com/lua/lua Everything is nicely documented and pretty easy to read. It's a great companion if you want to learn more about how languages are implemented.

Lua naturally avoids hashing strings as much as possible. Short strings always have their hash precomputed and local variables are internalized. The default method for implementing variable scopes in dynamic languages just uses a lot of hash tables, but Lua cleverly avoids this: https://github.com/lua/lua/blob/master/lobject.h#L549 https://github.com/lua/lua/blob/master/lstring.c#L185

Lua [1]. [1] https://github.com/lua/lua

Could be? https://github.com/lua/lua doesn't seem to have an /etc subdirectory and I think that's where I cloned from. Can totally believe the work had already been done by someone else and I failed to find it.

> Because of this development style, we prefer not to have a public repository for Lua. Note that I eventually convinced Roberto that it was worth having a public github repository even just to show the history and evolution. https://github.com/lua/lua

Very interesting article! Unfortunately, it doesn't mention Lua, which in my opinion has one of the most elegant C APIs that I have seen. It is entirely stack based, which means you only need to work with primitive types, such as numbers, C strings and user provided opaque pointers. As a consequence, you never have to care about memory management because Lua doesn't even let you access the actual Lua objects. You want to create a table (= Lua's dictionary/array hybrid) and set a field "foo" to 5? lua_newtable() creates a new table and pushes it onto the stack. Then you push "foo" with lua_pushstring() and 5 with lua_pushnumber(). Finally you call lua_settable(), which pops the key and value from the stack, checks if the top of the stack contains a table, and if yes, sets the given field to the given value. The actual table structure is ne

Lua uses "chained scatter" (linked list, but links point to other entries in the same table, to maintain locality): https://github.com/lua/lua/blob/master/ltable.c This is a good visual depiction of chained scatter: https://book.huihoo.com/data-structures-and-algorithms-with-... Inspired by Lua, I did the same for upb (https://github.com/protocolbuffers/upb). I recently benchmarked upb's table vs SwissTable for a string-keyed table and found upb was faster in both insert and lookup (in insert upb is beating SwissTable by 2x). It's true that the links do create more memory overhead though.

Given their limited shelf-life, I’d have thought this would be less of an issue for games than for other software? Many games rely on Lua, for example, which is maintained by a team of just 3 people, and it seems only one of them writes most of the code. https://github.com/lua/lua/graphs/contributors

Here's two arguments arguments in favor of 0-based 'indexing' (or offsets), that aren't just "because that's how it's done": 1. It is faster. Due to how memory works, 1-based languages need to subtract 1 internally every time you access an array[1]. 2. It works mathematically better with some of the most common operations on array offsets, like modulo and division into round/ceil/floor. You'll be peppering your code with +1 or -1 around those a lot if you use 1-based indexing. [1]: This is lua, for instance: https://github.com/lua/lua/blob/master/ltable.c#L702