lua

> 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