Home on Luatic's Bloarg

On string concatenation

Wed, 18 Feb 2026 00:00:00 +0000

When building strings, perhaps the first operation programmers learn, one of the few operators which tend to be introduced early on, is string concatenation. A simple, straightforward way to build strings.

In modern programming languages, strings are typically immutable, to avoid many of the surprises that may occur with mutable strings (and mutability in general). An advantage of this is that it enables string interning, which saves memory if many strings are duplicated and makes string comparisons cheap constant time pointer comparisons.

Python's variable scoping sucks

Sun, 08 Feb 2026 00:00:00 +0000

“[…] could you explain Python’s variable scoping rules?”

“Well, it’s very easy. They are local to arbitrarily defined block[s] unless they are not. In such case they are available only in otherwise arbitrarily defined blocks.”
– Aaa, on the Lua discord

How precisely it sucks is best demonstrated by example. I hope to convince you that maybe there are some aspects to Python that don’t exactly make it the friendliest language for a beginner to get into. A seasoned programmer will be able to cope with this, but might still be surprised about an edge case or two.

About

Mon, 12 Jan 2026 00:00:00 +0000

Hello there!

I’m Lars, a 21 year old computing nerd from Germany. You might also know me by one of a couple nicknames. ¹ In the last couple years, I have mostly been going by “luatic” online.

Programming

A lot of my life revolves around programming.

Due to a lucky coincidence, I started to learn programming relatively early, by making little 2d video games in Python. Since then, programming and related activities have become the thing I spend most of my time on. I’ve now programmed for well over a decade.

On ID generation

Mon, 12 Jan 2026 00:00:00 +0000

It happens very often in software that we have some kind of object and we want to give it some kind of unique identifier, called “ID” for short. It’s important that you get this right, or at least not horribly wrong. So here’s what you can do.

Use the object itself as ID

Why redo what the memory allocator already did: Allocate, for each unique object, a unique memory address. ¹

On cheating

Fri, 25 Jul 2025 00:00:00 +0000

Cheating is a problem as old as time.

The theoretical prevention is simple to state vaguely: “Harden” the protocol. Interactions need to be clearly defined. Players are only told what they need to know; they are restricted to legal actions as defined by the game rules.

This is relatively easy especially for well-defined simple board games, say, chess. The server can easily reject illegal moves; both players know the entire board state at all time. Yet the problem of cheating is not at all solved: Chess engines have outperformed even the very best human players since the days Kasparov lost to Deep Blue. Today any ordinary computer can obliterate a chess grandmaster. This brings us to our first fundamental problem:

Lua misconceptions

Sat, 12 Apr 2025 00:00:00 +0000

This is a collection of various Lua misconceptions I have seen over the years.

To clarify matters regarding language semantics, we refer to the manual guarantee; the relevant guarantees haven’t changed from version 5.1 through 5.4.

Unfortunately the reference manual mostly refrains from statements concerning performance, which plenty of misconceptions revolve around. To discuss performance characteristics, we look at the two most prevalent implementations, the reference implementation, PUC Lua, and LuaJIT, renowned for its speed.

Sticks and stones won't break my bones

Thu, 20 Feb 2025 00:00:00 +0000

… but Irrlicht will.

This software horror tale has all you expect: There’s an old legacy C++ codebase, a familiar culprit and ultimately, a bugfix followed by workarounds to put the bug back in to some extent.

The beginning

Many years ago Luanti (then called Minetest) suffered from a major bug: Skeletal keyframe-based animation and bone overrides could not be used together.

As soon as you overrode any bone, the entire model would cease animating.

Object-oriented programming (in Lua)

Sun, 07 Apr 2024 00:00:00 +0000

Time and time again, programming newcomers, through no fault of their own, are introduced to object-oriented programming (OOP) in languages that lead to a significant obstruction of the core principles of OOP.

Additionally, Lua newcomers have trouble understanding how to implement OOP in Lua, often resorting to replicating “patterns” found on the internet, leading to a very fuzzy notion of how it works and resulting in confusion when this does not behave as expected.

The case for closures (in Lua)

Sat, 16 Sep 2023 00:00:00 +0000

I have recently been criticized for my use of “nested” functions in Lua; the criticism revolved mostly about presumed performance problems (due to the cost of closure creation) and the claim that the usage of nested functions was “unnecessary” from a code quality standpoint. Here is my attempt at a thorough analysis, making a case for closures and more specifically the usage of “nested” functions in Lua.

Functional Programming

(Lua) closures alone suffice as Lambda Calculus - that is, closures paired with function application are Turing-complete. With higher-order functions, functional programming - fundamentally based on Lambda Calculus - is fully possible in Lua. Even just some very basic higher-order functions like map, filter or fold can already be very useful abstractions for working with iterators - most often implemented as closures, unless it is possible to efficiently wrap up their state in a single control variable + invariant state (as with ipairs and pairs) - but of course aren’t inexpensive in Lua; in much less dynamic languages like Rust, closures can often even be used as zero-cost abstractions.

Syntactic Sugar in Lua

Wed, 26 Jul 2023 00:00:00 +0000

Lua is a very minimalistic language. This doesn’t mean that it lacks syntactic sugar though; plenty of constructs native to other languages are “emulated” using more powerful constructs in Lua and thus need sugar for Lua to look & feel nice - Lua has more syntactic sugar than you may realize!

Table Indexing

Lua’s one-in-all datastructure is the table, which is array and hash map in one.

Since tables are used to implement data structures including “instances” of “classes”, accessing “fields” must be convenient. Lua thus provides the . indexing sugar:

On Quicksort

Sat, 15 Jul 2023 00:00:00 +0000

Quicksort is a rather popular sorting algorithm implemented by most standard libraries. Yet it has its shortcomings and special care needs to be taken to implement it properly. It is not uncommon for standard libraries to use a mix of sorting algorithms for the best performance, often using asymptotically suboptimal but simple algorithms like insertion sort once the problem has been sufficiently reduced and falling back to asymptotically reliable algorithms like heapsort if quicksort doesn’t progress fast enough (see for example Go’s mix of sorting algorithms under the hood).

Approximating π

Mon, 26 Jun 2023 00:00:00 +0000

Toying with a few intuitive (and less intuitive but more efficient) ways to approximate \(\pi\).

Throwing darts

This is perhaps the simplest method I’ve encountered yet - simple enough that you could teach it to absolute beginners once you’ve introduced math.random.

Based on the formula \(A = \pi r^2\) for the area A of a circle, \(\pi\) can be defined as the ratio of a circle with radius \(r\) to a square with both sides of length \(r\).

Backporting _ENV to Lua 5.1

Wed, 01 Mar 2023 00:00:00 +0000

Lua 5.2 has replaced setfenv(stacklevel_or_func, env) and getfenv(stacklevel_or_func) with assignments to / accesses of the implicit _ENV upvalue of each function:

The statement _ENV = env in a function is equivalent to setfenv(1, env), changing the current function environment to env, and the expression _ENV is equivalent to getfenv(1), getting the current function environment.

By using setfenv and debug.sethook, this “feature” can be (superficially) added to all Lua functions: Whenever a function is called, the environment is hooked using a proxy table to provide special treatment for assigning to (__newindex) or getting (__index) _ENV.

On the misconception that const is recursive

Wed, 01 Mar 2023 00:00:00 +0000

The const keyword applies only to variables - not to the contents of variables. The following is valid JavaScript (Java’s final or Lua’s local <const> are analogeous):

const p = {x: 1, y: 2};
p.x = 3;

since p is not assigned to.

const p = {x: 1, y: 2};
p = {x: 42, y: 33};

would be illegal however.

JavaScript provides Object.freeze to make an object immutable (which again only is shallow though!):

Lua Quines

Sat, 25 Feb 2023 00:00:00 +0000

Cheating Quines

The Trivial Quine

The empty string `` technically is a quine in most scripting languages since it outputs itself - nothing, the empty string - when run.

A Debug Quine

Reads its own source. May not work if the source file has been moved.

Also works if the quine is not loaded from a file (i.e. loaded from a string), as long as no “name” has been passed (doesn’t work in the Lua REPL, since there the source will be =stdin).

How RegEx implementations suck

Tue, 21 Feb 2023 00:00:00 +0000

Regular languages are a powerful and beautiful formal tool to validate or parse strings.

Yet “regular” expression (“RegEx[p]”) implementations are often despised by programmers for a couple (good) reasons:

More than just RegEx

Part of what keeps regular languages and the theory surrounding them simple is their limitations: Regular languages can’t count infinitely; they can’t match brackets or keep track of indentation.

This led to hacky extensions to RegEx to add such “features” like backreferences (which is even more powerful than counting) or bracket matching, extending the expressiveness of RegEx beyond that of regular grammars, making regular expressions nonregular and often matching context-free grammars (CFGs) or - even worse - context-sensitive grammars, which in turn 99% of the time is backed by a horribly inefficient implementation.

The coroutine stack

Tue, 21 Feb 2023 00:00:00 +0000

A coroutine + callstack-based stack of varargs in pure Lua. Inspired by this tweet.

Note: Currently, for the sake of simplicity, only a single stack is implemented. By parameterizing each function in terms of the stack, multiple stacks could be implemented, but this is not for practical purposes (in practice, you should usually use tables paired with table.insert and table.remove instead, unless your problem lends itself well to a recursive solution; keep stack overflows in mind though).

Why some things are bound to be janky in Luanti

Tue, 21 Feb 2023 00:00:00 +0000

So, you want(ed) to write a bow mod. It’s time to confront you with the harsh reality of just how limited the Luanti engine is.

Disclaimer: Some concepts for the “ideal bow mod” detailed below are not feasible to be implemented and are mostly of theoretical nature.

Visuals

You probably don’t want your arrows to be a bunch of sprites, so your only option is to use a heavyweight entity with a mesh visual. Spamming arrows may drag FPS down (due to lack of batching - one drawcall is issued for each entity); additionally, each arrow will generate significant network traffic and increase the time required to find any entities since all entities reside in the same global set to be searched linearly for each and every query (see also poor collision performance and attempts to use spatial indexing).