Funny how I get captcha looped with my adblocking in firefox but you can just get through easily with a few puppeteer plugins controlling headless chrome.
LLMs are the wrong tool for video games. There have been plenty of successful non-LLM AIs that have been trained with reinforcement learning to play games.
If you want to implement actual bots inside the game, then you want to use explicit logic instead of inferred logic. It's much more efficient and easier to debug.
The nice thing about Lua is that it can easily be combined with compiled languages. If you identify the hot path in your program, you can implement them in a more efficient language.
The C interface to ruby is just superb. It provides a very simple and first class access to the entire runtime and all it's features. It's absolutely my favorite language to write extensions in.
Lua is probably my second favorite. It's marred by it's initial creation as a stack based interpreter and requires more calls and contortions to achieve the same effects as you would in any other language; however, once you understand a handful of useful primitives it's quite easy to intuit the correct set of calls for any use case.
The blend of dynamic language with underlying compiled extensions is vastly underappreciated. I suspect it has a lot to do with the difficulty of packaging and distributing these extensions into current virtualized and cloud environments. Which is a pity given the extreme combination of flexibility and efficiency that it otherwise unlocks.
How does it handle garbage collection? AFAIK GC is the main reason behind Lua's stack-based API: it's designed so that C code never needs to hold a pointer to a Lua object, which means an object will never be garbage-collected while C code is still trying to use it.
OTOH Python does allow C code to hold such pointers - so it requires that code to perform error-prone manual reference-counting.
The interpreter keeps track of globals and all stack frames. So it knows what objects are in scope.
If you're creating an object that can contain native ruby values inside it's own opaque structure, then when you define the class that wraps this structure you reference the callback functions you want to be called during GC mark and when the GC frees your object. During the mark callback you simply call rb_gc_mark on any of those internal values so the GC knows they are in scope.
In practice it's quite easy to use and you can find many examples of this. There is no equivalent I'm aware of to mark in lua, but the free callback is effectively equivalent to the __gc metamethod.
> Latin language should be become the official language of the EU
It would be more practical, if everyone spoke the same language, but the EU does deliberately not want that. The EU wants to preserve language and culture of its member states and regions. "United in Diversity" is an important idea of the EU.
I think the emphasis is on official. That is, it would function as the common language of administration, communication, diplomacy, etc. (i.e., lingua franca), but it wouldn't replace vernacular languages. This was the norm centuries ago in Europe.
One advantage of it being "dead" is that the meanings of terms are much more stable. They don't undergo the usual slippage and mutation of spoken languages. This advantage would be lost if it were to replace existing vernacular languages.
Parts of the EU say that, then at other times other parts act inconsistently with it. I was just at a meeting of an EU body where it was emphasized that, when considering the language of European patents written in English, courts would deliberately interpret the text as having been written by a native English speaker, even when it was clear that the author was a native speaker of a different EU language, for example, in cases where the author was clearly following a grammatical convention of their native language (eg, in comma placement) that might be awkward or ambiguous in English.
While that might make sense from a legal standpoint, it seems like it makes it risky to hire patent lawyers in Europe who are not native English speakers, which in turn, along with many other similar inconsistencies, does in practice create an EU-preferred language.
> This allows reviewers to step through your pull request in small bites, with each set of changes scoped to a single aspect of the feature.
Is that a frequent way of reviewing? On GitHub you get shown all changes together in the review tab. You can select individual commits for closer inspection, but where is the benefit?
I suspect there is some weird habit that some people even like to overengineer their git history. Maybe it improves the pixel fame ratio or something.
For me it's satire. There are reasons for varying effort in creating PRs or patches, but attempts like this never seem to reason about reality. If I have to review, I want to see the code, not a clever story hidden in the commit history.
reply