# Lua

Published articles for Lua.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Creator of Lua: Scripting, Programming Languages, Predictions | Roberto Ierusalimschy

DevFeed: [Creator of Lua: Scripting, Programming Languages, Predictions | Roberto Ierusalimschy](<https://devfeed.tech/articles/creator-of-lua-scripting-programming-languages-predictions-roberto-ierusalimschy-18087.md>)

Original publisher: [Read original article](<https://www.developing.dev/p/creator-of-lua-scripting-programming>)

Author: Ryan Peterman

Published: 2026-08-03T13:05:15Z

Content type: article

Language: en

Sources: [The Developing Dev](<https://devfeed.tech/sources/the-developing-dev.md>)

Topics: [Lua](<https://devfeed.tech/topics/lua.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Scripting](<https://devfeed.tech/topics/scripting.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [C](<https://devfeed.tech/topics/c.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [lua](<https://devfeed.tech/tags/lua.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>), [python](<https://devfeed.tech/tags/python.md>), [scripting](<https://devfeed.tech/tags/scripting.md>)

### AI overview

A conversation with Lua creator Roberto Ierusalimschy explains how Lua works as an embeddable scripting language alongside C or C++, including how applications can call Lua or Lua can call C. The discussion also covers Lua's use in games such as World of Warcraft and Roblox and recommendations for learning other programming languages.

### Source excerpt

When I worked at Instagram, most of the codebase was in Python but occasionally I'd see these bindings into C++.

## Managing Multiple Lua Scripts with Ceph Object Storage

DevFeed: [Managing Multiple Lua Scripts with Ceph Object Storage](<https://devfeed.tech/articles/managing-multiple-lua-scripts-with-ceph-object-storage-12338.md>)

Original publisher: [Read original article](<https://ceph.io/en/news/blog/2026/rgw-multiple-scripts/>)

Author: Kirby Chin

Published: 2026-06-10T00:00:00Z

Content type: article

Language: en

Sources: [Ceph Blog](<https://devfeed.tech/sources/ceph-blog.md>)

Topics: [Lua](<https://devfeed.tech/topics/lua.md>), [Script](<https://devfeed.tech/topics/script.md>), [Scripting](<https://devfeed.tech/topics/scripting.md>), [Security](<https://devfeed.tech/topics/security.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>), [ransomware](<https://devfeed.tech/topics/ransomware.md>)

Tags: [availability](<https://devfeed.tech/tags/availability.md>), [blog](<https://devfeed.tech/tags/blog.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [ceph](<https://devfeed.tech/tags/ceph.md>), [cli](<https://devfeed.tech/tags/cli.md>), [data](<https://devfeed.tech/tags/data.md>), [developer](<https://devfeed.tech/tags/developer.md>), [en-article](<https://devfeed.tech/tags/en-article.md>), [en-blog-post](<https://devfeed.tech/tags/en-blog-post.md>), [examples](<https://devfeed.tech/tags/examples.md>), [feature](<https://devfeed.tech/tags/feature.md>), [go](<https://devfeed.tech/tags/go.md>), [lua](<https://devfeed.tech/tags/lua.md>), [management](<https://devfeed.tech/tags/management.md>), [new-feature](<https://devfeed.tech/tags/new-feature.md>), [object-storage](<https://devfeed.tech/tags/object-storage.md>), [operations](<https://devfeed.tech/tags/operations.md>), [rados](<https://devfeed.tech/tags/rados.md>), [ransomware](<https://devfeed.tech/tags/ransomware.md>), [rgw](<https://devfeed.tech/tags/rgw.md>), [s3](<https://devfeed.tech/tags/s3.md>), [scripting](<https://devfeed.tech/tags/scripting.md>), [security](<https://devfeed.tech/tags/security.md>), [storage](<https://devfeed.tech/tags/storage.md>)

### AI overview

This article introduces a Ceph RADOS Gateway feature for managing multiple Lua scripts within the same request context and tenant. It demonstrates scripts for enforcing bucket object locks to mitigate ransomware risks and for optimizing storage through object auto-tiering.

### Source excerpt

Since the Pacific release, Lua scripting in Ceph's RADOS Gateway (RGW) has provided users the ability to interpolate a single script to upload operations per request context and tenant. This way of working might be completely fine for a storage deployment with limited scripting customizations. However, script management becomes increasingly difficult as more than one team wants to get involved in managing the Lua script within the same context and tenant. For this reason, we've released a new feature in RGW allowing you to manage more than one Lua script at a time. In this blog, we'll go over a couple of examples to walk you through how this feature can help your team to reduce runtime errors and lower developer friction when managing Lua scripts in RGW. To begin, we will create a script to enforce a bucket security control and then add another script to demonstrate the new feature. Script 1: Bucket security ¶ Let's suppose we are part of a security team and want to mitigate the risk of ransomware threats happening on our storage platform. One possible way to achieve this is to implement a Write Once, Read Many (WORM) strategy to add an object lock onto any newly created bucket. By using an object lock, we can add a constraint to write objects to disk only once, ensuring that an infected client cannot delete or override objects at a later time. To set our WORM strategy, we can create a Lua script in the prerequest context that aborts when a create_bucket operation is made without the write-once (object lock) requirement. objectlock.lua -- enforcing object lock on bucket creation if Request.RGWOp == "create_bucket" and Request.HTTP.Metadata["x-amz-bucket-object-lock-enabled"] ~= "true" then RGWDebugLog("object lock is missing on bucket: " .. Request.Bucket.Name) Request.Response.Message = "Bucket must have object lock enabled" return RGW_ABORT_REQUEST end You can create a new objectlock.lua file with the contents above and run the CLI commands below to upload the scr

## Why do developers count from zero?

DevFeed: [Why do developers count from zero?](<https://devfeed.tech/articles/why-do-developers-count-from-zero-39319.md>)

Original publisher: [Read original article](<https://kt.academy/article/index_zero>)

Published: 2026-04-27T00:00:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [C](<https://devfeed.tech/topics/c.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [The Julia Language](<https://devfeed.tech/topics/julia.md>), [Lua](<https://devfeed.tech/topics/lua.md>), [MATLAB](<https://devfeed.tech/topics/matlab.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [developers](<https://devfeed.tech/tags/developers.md>), [history](<https://devfeed.tech/tags/history.md>), [lua](<https://devfeed.tech/tags/lua.md>), [matlab](<https://devfeed.tech/tags/matlab.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This video explains why zero-based indexing became common. It discusses efficient use of numeric values and the simpler memory-address formula for arrays, while noting that MATLAB, Lua, and Julia use one-based indexing.

### Source excerpt

Why do developers count from zero? Short history and reasoning behind this convention.

## Balatro's Least Erratic Decks

DevFeed: [Balatro's Least Erratic Decks](<https://devfeed.tech/articles/balatro-s-least-erratic-decks-38394.md>)

Original publisher: [Read original article](<https://blog.danlew.net/2025/11/03/balatros-least-erratic-decks/>)

Author: Dan Lew

Published: 2025-11-03T13:00:52Z

Content type: article

Language: en

Sources: [Dan Lew Blog](<https://devfeed.tech/sources/dan-lew-blog.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Lua](<https://devfeed.tech/topics/lua.md>), [optimize](<https://devfeed.tech/topics/optimize.md>), [LÖVE](<https://devfeed.tech/topics/love2d.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [bug](<https://devfeed.tech/topics/bug.md>), [cpu](<https://devfeed.tech/topics/cpu.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [bug](<https://devfeed.tech/tags/bug.md>), [code](<https://devfeed.tech/tags/code.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [game](<https://devfeed.tech/tags/game.md>), [games](<https://devfeed.tech/tags/games.md>), [jit](<https://devfeed.tech/tags/jit.md>), [lua](<https://devfeed.tech/tags/lua.md>), [optimize](<https://devfeed.tech/tags/optimize.md>), [rust](<https://devfeed.tech/tags/rust.md>)

### AI overview

The author searches for the least erratic Erratic deck in Balatro by examining every possible game seed. After finding Lua too slow for the 2.3 trillion-seed search, they optimize the Lua implementation and then port it to Rust, using all CPU cores to reach about 100 million seeds per minute. The article also explains a bug that can produce decks filled with the ten of spades.

### Source excerpt

My most recent "just for fun" project was to find the least erratic of the Erratic decks in Balatro (a poker-ish roguelike deckbuilder game). Before each game, you pick a deck that has a special power. The Erratic deck completely randomizes the ranks/suits of the cards

## Scaling Nextdoor's Datastores: Part 4

DevFeed: [Scaling Nextdoor's Datastores: Part 4](<https://devfeed.tech/articles/scaling-nextdoor-s-datastores-part-4-20343.md>)

Original publisher: [Read original article](<https://engblog.nextdoor.com/scaling-nextdoors-datastores-part-4-c9d3d3edcd34?source=rss----5e54f11cdfdf---4>)

Author: Ronak Shah

Published: 2025-03-19T15:08:57Z

Content type: article

Language: en

Sources: [Nextdoor](<https://devfeed.tech/sources/nextdoor.md>)

Topics: [Cache](<https://devfeed.tech/topics/cache.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [cache-control](<https://devfeed.tech/tags/cache-control.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [database](<https://devfeed.tech/tags/database.md>), [database-consistency](<https://devfeed.tech/tags/database-consistency.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [examples](<https://devfeed.tech/tags/examples.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [lua](<https://devfeed.tech/tags/lua.md>)

### AI overview

Part 4 of Nextdoor's datastore series explains how racing database writes can update a cache in a different order, allowing stale writes and leaving the cache inconsistent with the database. It introduces the problem and notes that the full solution will be covered in a later installment.

### Source excerpt

In this part of the Scaling Nextdoor's Datastores blog series, we will see how the Core-Services team at Nextdoor keeps its cache consistent with database updates and avoids stale writes to the cache. In this post, we'll focus specifically on inconsistencies caused by racing writes and our solution. We'll discuss other causes and our full solution for consistent caching in the next installment of our blog: Part 5: A time-bounded eventually-consistent cache. Inconsistent Cache Caches can become inconsistent with the database for several reasons, such as: Racing Writes / Concurrent Updates: Multiple writes occurring simultaneously can result in a stale cache. Missed Writes / Failing to Update the Cache: Failure to update or set cache correctly after a database write. Delayed Cache Updates or Deletes: Slow propagation of updates or invalidation can leave the cache out of sync. Application-Level Bugs: Bugs in application side caching logic. Maintaining cache consistency with the database is crucial for data accuracy, especially in distributed systems with concurrent web requests. Consistent caching ensures reliable read-after-write behavior, improving performance and user experience. Without it, applications may face unpredictable behavior and user frustration. A well-designed caching system boosts performance, ensures consistency, and delivers up-to-date data even under high concurrency. Racing Writes Let's look at the scenario where two writers, A and B, update the same user in the database but write to the cache in a different order, causing the cache to become inconsistent with the database. Author's Note: In examples moving forward we'll use "User_1" to mean id=1 in the "users" table.Look-Aside Cache with two writers. Sequence of operations: Writer A updates the name of user_1 to Foo in the database. Writer B updates the name of the same user_1 to Bar in the database. Writer B updates the cache for user_1 with name = Bar. Writer A updates the cache for user_1 with

## Scaling Nextdoor's Datastores: Part 3

DevFeed: [Scaling Nextdoor's Datastores: Part 3](<https://devfeed.tech/articles/scaling-nextdoor-s-datastores-part-3-20342.md>)

Original publisher: [Read original article](<https://engblog.nextdoor.com/scaling-nextdoors-datastores-part-3-e9b4dd8a9393?source=rss----5e54f11cdfdf---4>)

Author: Ronak Shah

Published: 2025-03-19T15:08:43Z

Content type: article

Language: en

Sources: [Nextdoor](<https://devfeed.tech/sources/nextdoor.md>)

Topics: [Caching](<https://devfeed.tech/topics/caching.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [schema-evolution](<https://devfeed.tech/topics/schema-evolution.md>), [Object-relational mapping](<https://devfeed.tech/topics/orm.md>), [Django](<https://devfeed.tech/topics/django.md>), [Python](<https://devfeed.tech/topics/python.md>), [Redis](<https://devfeed.tech/topics/redis.md>), [valkey](<https://devfeed.tech/topics/valkey.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [compatibility](<https://devfeed.tech/tags/compatibility.md>), [database](<https://devfeed.tech/tags/database.md>), [django](<https://devfeed.tech/tags/django.md>), [lua](<https://devfeed.tech/tags/lua.md>), [python](<https://devfeed.tech/tags/python.md>), [redis](<https://devfeed.tech/tags/redis.md>), [schema](<https://devfeed.tech/tags/schema.md>), [serialization-format](<https://devfeed.tech/tags/serialization-format.md>), [thundering-herd](<https://devfeed.tech/tags/thundering-herd.md>), [valkey](<https://devfeed.tech/tags/valkey.md>)

### AI overview

Part 3 of Nextdoor's datastore-scaling series explains how applications serialize database objects for Redis or Valkey look-aside caches. It describes compatibility problems caused by runtime, package, and schema changes, including cache misses and thundering-herd effects during migrations.

### Source excerpt

In this part of the Scaling Nextdoor's Datastores blog series, we'll explore how the Core-Services team at Nextdoor serializes database data for caching while ensuring forward and backward compatibility between the cache and application code. In part 1 of this series we discussed how ORMs, object-relational mapping frameworks, help abstract away database specific schemas and queries from application code. Developers simply utilize objects in their application's language to access database data. Here's a simple example of using Python's Django ORM to define a model: from django.db import models class Users(models.Model): first_name = models.CharField(max_length=30) last_name = models.CharField(max_length=30) The associated SQL create table would look like: CREATE TABLE users ( "id" bigint NOT NULL PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY, "first_name" varchar(30) NOT NULL, "last_name" varchar(30) NOT NULL ); Developers would then access database data like this: user_id = 123 user = User.objects.get(id=user_id) print(user.first_name)Object Byte Serialization for Caching An issue arises when adding a look-aside cache such as Redis/Valkey to an application: How do you store what you got from the database in the cache? A common solution to caching complex objects, such as those from ORMs, is object byte serialization. This process converts language objects into bytes before storing them in the cache. When reading from the cache the process is done in reverse where the byte data is turned into language objects. For instance in Python this is often done with the pickle package. The interaction between the application, database, and the cache looks like this: Look-Aside Cacheimport pickle # Try getting from cache ('None' if not in cache) user_bytes = cache.get("user_123") if user_bytes is not None: # Read bytes using pickle user = pickle.loads(user_bytes) else: # Fetch from database user = User.objects.get(id=123) # Convert to bytes user_bytes = pickle.dumps(user) # Sto

## Writing a Keycloak-PKCE Library in C++

DevFeed: [Writing a Keycloak-PKCE Library in C++](<https://devfeed.tech/articles/writing-a-keycloak-pkce-library-in-c-25141.md>)

Original publisher: [Read original article](<https://blog.brakmic.com/writing-a-keycloak-pkce-library-in-c/>)

Author: brakmic

Published: 2025-02-28T18:48:58Z

Content type: article

Language: en

Sources: [Harris Brakmic - Coding](<https://devfeed.tech/sources/harris-brakmic-coding.md>)

Topics: [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Keycloak](<https://devfeed.tech/topics/keycloak.md>), [pkce](<https://devfeed.tech/topics/pkce.md>), [Library](<https://devfeed.tech/topics/library.md>), [C](<https://devfeed.tech/topics/c.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Python](<https://devfeed.tech/topics/python.md>), [Lua](<https://devfeed.tech/topics/lua.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [article](<https://devfeed.tech/tags/article.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [coding](<https://devfeed.tech/tags/coding.md>), [keycloak](<https://devfeed.tech/tags/keycloak.md>), [learning](<https://devfeed.tech/tags/learning.md>), [library](<https://devfeed.tech/tags/library.md>), [lua](<https://devfeed.tech/tags/lua.md>), [pkce](<https://devfeed.tech/tags/pkce.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

A personal article about building a C++ library that supports PKCE with Keycloak. The project includes a C wrapper with a stable ABI and additional Python and Lua wrappers, and is presented primarily as a learning exercise rather than a production-ready library.

### Source excerpt

This article offers a personal look at a C++ library implementing PKCE with Keycloak. It's intended more as a learning exercise than a production-ready solution. You'll find a C wrapper and additional Python and Lua wrappers, plus a quick rundown on PKCE fundamentals, library structure, and example demos.

## A Tail Calling Interpreter For Python (And Other Updates)

DevFeed: [A Tail Calling Interpreter For Python (And Other Updates)](<https://devfeed.tech/articles/a-tail-calling-interpreter-for-python-and-other-updates-21140.md>)

Original publisher: [Read original article](<https://blog.reverberate.org/2025/02/10/tail-call-updates.html>)

Author: Haberman

Published: 2025-02-10T00:00:00Z

Content type: opinion

Language: en

Sources: [Josh Haberman](<https://devfeed.tech/sources/josh-haberman.md>)

Topics: [Parsing](<https://devfeed.tech/topics/parsing.md>), [Python 3.14](<https://devfeed.tech/topics/python-3-14.md>), [Python](<https://devfeed.tech/topics/python.md>), [Lua](<https://devfeed.tech/topics/lua.md>), [JIT](<https://devfeed.tech/topics/jit.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [jit](<https://devfeed.tech/tags/jit.md>), [lua](<https://devfeed.tech/tags/lua.md>), [parsing](<https://devfeed.tech/tags/parsing.md>), [python](<https://devfeed.tech/tags/python.md>), [python-3-14](<https://devfeed.tech/tags/python-3-14.md>)

### AI overview

The article updates readers on tail-call interpreter developments following the author's earlier work. It reports that Python's tail-calling interpreter was merged and is slated for Python 3.14, with an opt-in configuration requirement, and discusses the experimental LuaJIT Remake project and its use of tail-call techniques.

### Source excerpt

It's been nearly four years since I published Parsing Protobuf at 2+GB/s: How I Learned To Love Tail Calls in C. In that article, I presented a technique I co-developed for how to write really fast interpreters through the use of tail calls and the musttail attribute. While the article focused on Protocol Buffer parsers, the technique applies to many kinds of parsers and VM interpreters. I published the article in the hopes that the technique would catch on and be adopted in other projects. In the time since that article was published, there have been many exciting developments in this space. I want to take this opportunity to share some updates. Tail Calling Interpreter for Python I recently learned that a tail calling interpreter was going through PR review on GitHub. Authored by Ken Jin as part of his Bachelor's theses, it uses the techniques described in my article and claims a 9-15% improvement geomean improvement on pyperformance, the official Python benchmark suite. Last Friday that interpreter was merged, and it is officially slated to be released in Python 3.14 (release notes). Note that the tail call interpreter is not the default yet. It has to be enabled at configuration time with --with-tail-call-interp. Hopefully it will be the default in a future release. I'm very excited to see this development. In my original article, I made the following prediction: I think it's likely that all of the major language interpreters written in C (Python, Ruby, PHP, Lua, etc.) could get significant performance benefits by adopting this technique. I'm happy to see that this seems to have come true for Python. Congratulations to Ken on this accomplishment. Tail Calling Interpreter for LuaJIT Remake In 2022-2024, Haoran Xu published a series of articles and papers about an ambitious and experimental effort to automatically generate interpreters and JIT compilers from a description of the language semantics. This project is called Deegen, and Haoran used it to build LuaJIT

## Using Lua as ESP-IDF Component with ESP32

DevFeed: [Using Lua as ESP-IDF Component with ESP32](<https://devfeed.tech/articles/using-lua-as-esp-idf-component-with-esp32-13968.md>)

Original publisher: [Read original article](<https://developer.espressif.com/blog/using-lua-as-esp-idf-component-with-esp32/>)

Author: John Lee

Published: 2024-10-22T00:00:00Z

Content type: tutorial

Language: en

Sources: [Blog on Developer Portal](<https://devfeed.tech/sources/blog-on-developer-portal.md>)

Topics: [Lua](<https://devfeed.tech/topics/lua.md>), [ESP-IDF](<https://devfeed.tech/topics/esp-idf.md>), [ESP32](<https://devfeed.tech/topics/esp32.md>), [Embedded Systems](<https://devfeed.tech/topics/embedded-systems.md>), [Scripting](<https://devfeed.tech/topics/scripting.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [component](<https://devfeed.tech/tags/component.md>), [embedded-systems](<https://devfeed.tech/tags/embedded-systems.md>), [esp-idf](<https://devfeed.tech/tags/esp-idf.md>), [esp32](<https://devfeed.tech/tags/esp32.md>), [esp32-c3](<https://devfeed.tech/tags/esp32-c3.md>), [firmware](<https://devfeed.tech/tags/firmware.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [lua](<https://devfeed.tech/tags/lua.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [risc-v](<https://devfeed.tech/tags/risc-v.md>), [scripting](<https://devfeed.tech/tags/scripting.md>), [spiffs](<https://devfeed.tech/tags/spiffs.md>)

### AI overview

This tutorial explains how to integrate Lua as an ESP-IDF component in ESP32 projects and run Lua scripts from the SPIFFS filesystem. It covers the example project, cross-architecture support for ESP32 and ESP32-C3, configurable Lua stack size, and memory monitoring while Wi-Fi is enabled.

### Source excerpt

Lua is a lightweight and powerful scripting language, making it ideal for use in embedded systems like the ESP32. By integrating Lua into your ESP-IDF project, you can execute scripts directly on the ESP32, offering a flexible way to manage application behavior without recompiling the entire firmware. This guide walks through how to set up Lua as an ESP-IDF component, with a focus on running Lua scripts from the filesystem.

## Introducing NPC-Playground, a 3D playground to interact with LLM-powered NPCs

DevFeed: [Introducing NPC-Playground, a 3D playground to interact with LLM-powered NPCs](<https://devfeed.tech/articles/introducing-npc-playground-a-3d-playground-to-interact-with-llm-powered-npcs-7367.md>)

Original publisher: [Read original article](<https://huggingface.co/blog/npc-gigax-cubzh>)

Author: Tristan Deborde; Duermael; Gaetan de Villele; Corentin CAILLEAUD; Thomas Simonini

Published: 2024-06-05T00:00:00Z

Content type: article

Language: en

Sources: [Hugging Face - Blog](<https://devfeed.tech/sources/hugging-face-blog.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [3D](<https://devfeed.tech/topics/3d.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [hugging face](<https://devfeed.tech/topics/hugging-face.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Lua](<https://devfeed.tech/topics/lua.md>), [spaces](<https://devfeed.tech/topics/spaces.md>), [GitHub](<https://devfeed.tech/topics/github.md>)

Tags: [3d](<https://devfeed.tech/tags/3d.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [game-dev](<https://devfeed.tech/tags/game-dev.md>), [github](<https://devfeed.tech/tags/github.md>), [hugging-face](<https://devfeed.tech/tags/hugging-face.md>), [llm](<https://devfeed.tech/tags/llm.md>), [lua](<https://devfeed.tech/tags/lua.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [spaces](<https://devfeed.tech/tags/spaces.md>)

### AI overview

Hugging Face introduces NPC-Playground, a browser-based 3D demo from Cubzh and Gigax featuring LLM-powered non-player characters. Users can interact with the NPCs and teach them skills through Lua scripting. The article describes Cubzh, Gigax's NPC platform and inference stack, and the use of Hugging Face Spaces to host the demo.

### Source excerpt

We're on a journey to advance and democratize artificial intelligence through open source and open science.

## A PDP-8 Emulator Revisited on the iPad

DevFeed: [A PDP-8 Emulator Revisited on the iPad](<https://devfeed.tech/articles/roots-21796.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2021/09/25/roots.html>)

Published: 2021-09-25T00:00:00Z

Content type: opinion

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Emulator](<https://devfeed.tech/topics/emulator.md>), [Lua](<https://devfeed.tech/topics/lua.md>), [Code](<https://devfeed.tech/topics/code.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [App](<https://devfeed.tech/topics/app.md>)

Tags: [app](<https://devfeed.tech/tags/app.md>), [code](<https://devfeed.tech/tags/code.md>), [emulator](<https://devfeed.tech/tags/emulator.md>), [github](<https://devfeed.tech/tags/github.md>), [lua](<https://devfeed.tech/tags/lua.md>)

### AI overview

The author recounts building a PDP-8 emulator in Codea on an iPad, losing access to it after Apple restricted source-code sharing, and later restoring and updating it from GitHub.

### Source excerpt

When I was 15 or so, my father would drive me, and my best friend, Tim Conrad, to the Digital Equipment Corporation (DEC) sales office each Saturday. This was a 30 min drive. My father would drop us off in the morning and pick us up in the late afternoon. He spend two hours in his car each Saturday hauling us around. Thanks Dad! Tim and I would spend our day "playing" with the floor model of the PDP-8 they had at the office. The office staff were very accommodating and accepting of our presence, and they helped us out if we needed any fresh rolls of teleprinter paper, or paper tape. Several years later, at the age of 20, I found myself working at Teradyne Applied Systems in Chicago. The computer we used there was called an M365; but it was really just an upgraded PDP-8. We used it to control lasers in order to trim electronic components to very precise values. Forty four years later, in May of 2015, I started playing with a cute little Lua environment on my iPad called Codea. I wrote several fun little programs, like lunar lander, etc. But then I thought: "Wouldn't it be fun to write a PDP-8 Emulator?" A few days/weeks later I had a nice little PDP-8 emulator running on my iPad. I found some archived binary images of ancient paper tapes and managed to load them into my emulator. This allowed me to run the suite of development tools that I had used back in those early days. Then Apple decided it didn't want people writing code on the Ipad that was not distributed through the App store, so they blocked the means by which Codea users could share source code. Indeed, I couldn't even move Lua source code to my new iPads. So the emulator was lost. Fortunately I had put the last working version up on GitHub. At some point, Apple reopened the channel, perhaps due to a court case. I discovered this a few weeks back, and loaded that old source code back into my iPad. It worked like a champ. I made a few changes to deal with the bigger screen, and the faster processor, and the

## How Shopify Dynamically Routes Storefront Traffic

DevFeed: [How Shopify Dynamically Routes Storefront Traffic](<https://devfeed.tech/articles/how-shopify-dynamically-routes-storefront-traffic-1377.md>)

Original publisher: [Read original article](<https://shopify.engineering/dynamically-route-storefront-traffic>)

Author: Derek Stride

Published: 2021-04-09T20:19:44Z

Content type: article

Language: en

Sources: [Shopify Engineering](<https://devfeed.tech/sources/shopify-engineering.md>), [Shopify Engineering - Shopify Engineering](<https://devfeed.tech/sources/shopify-engineering-shopify-engineering.md>)

Topics: [Shopify](<https://devfeed.tech/topics/shopify.md>), [nginx](<https://devfeed.tech/topics/nginx.md>), [Lua](<https://devfeed.tech/topics/lua.md>), [Server-side rendering](<https://devfeed.tech/topics/server-side-rendering.md>), [JSON](<https://devfeed.tech/topics/json.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Caching](<https://devfeed.tech/topics/caching.md>)

Tags: [caching](<https://devfeed.tech/tags/caching.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [json](<https://devfeed.tech/tags/json.md>), [load-balancer](<https://devfeed.tech/tags/load-balancer.md>), [lua](<https://devfeed.tech/tags/lua.md>), [nginx](<https://devfeed.tech/tags/nginx.md>), [routing](<https://devfeed.tech/tags/routing.md>), [server-side-rendering](<https://devfeed.tech/tags/server-side-rendering.md>), [shopify](<https://devfeed.tech/tags/shopify.md>)

### AI overview

Shopify describes how its Storefront Renderer team dynamically routes traffic between legacy and new storefronts using nginx with OpenResty, Lua-based verification and routing rules, and a control plane. Moving rule management into the control plane enabled rapid updates without the usual CI and deployment cycle, while retaining code review for sensitive commands.

### Source excerpt

In 2019 we set out to rewrite the Shopify storefront implementation. Our goal was to make it faster. We talked about the strategies we used to achieve that goal in a previous post about optimizing server-side rendering and implementing efficient caching. To build on that post, I'll go into detail on how the Storefront Renderer team tweaked our load balancers to shift traffic between the legacy storefront and the new storefront. First, let's take a look at the technologies we used.

## A 2019 update on PowerDNS, Galileo, DoH and other things

DevFeed: [A 2019 update on PowerDNS, Galileo, DoH and other things](<https://devfeed.tech/articles/a-2019-update-on-powerdns-galileo-doh-and-other-things-36573.md>)

Original publisher: [Read original article](<https://berthub.eu/articles/posts/update-2019-powerdns-galileo-ripe-doh/>)

Published: 2020-01-01T14:37:52Z

Content type: article

Language: en

Sources: [Bert Hubert's writings](<https://devfeed.tech/sources/bert-hubert-s-writings.md>)

Topics: [powerdns](<https://devfeed.tech/topics/powerdns.md>), [Internet](<https://devfeed.tech/topics/internet.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [diary](<https://devfeed.tech/tags/diary.md>), [dns](<https://devfeed.tech/tags/dns.md>), [gnss](<https://devfeed.tech/tags/gnss.md>), [lua](<https://devfeed.tech/tags/lua.md>), [powerdns](<https://devfeed.tech/tags/powerdns.md>), [privacy](<https://devfeed.tech/tags/privacy.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

A 2019 professional update covering the author's work on PowerDNS, DNS over HTTPS, Galileo, and related community and advisory activities. The article also explains that the PowerDNS team had taken full responsibility for day-to-day management and technical decisions.

### Source excerpt

Last year I wrote a post listing what I had been doing in 2018, because it turned out it was a lot, so much that it was useful to summarise it somewhat. This year there is less to report, but people have wondered what I've been up to. And I've learned that if you leave room for speculation about your intentions, wrong answers tend to come up. This (professional) year for me mostly consisted of two things: DNS over HTTPS and Galileo.

## Redis Lua scripting: several security vulnerabilities fixed

DevFeed: [Redis Lua scripting: several security vulnerabilities fixed](<https://devfeed.tech/articles/redis-lua-scripting-several-security-vulnerabilities-fixed-20610.md>)

Original publisher: [Read original article](<http://antirez.com/news/119>)

Published: 2018-06-13T17:15:05Z

Content type: opinion

Language: en

Sources: [Antirez](<https://devfeed.tech/sources/antirez.md>)

Topics: [Redis](<https://devfeed.tech/topics/redis.md>), [Vulnerabilities](<https://devfeed.tech/topics/vulnerabilities.md>), [Lua](<https://devfeed.tech/topics/lua.md>), [Security](<https://devfeed.tech/topics/security.md>), [Multi-tenancy](<https://devfeed.tech/topics/multi-tenancy.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [cloud](<https://devfeed.tech/tags/cloud.md>), [lua](<https://devfeed.tech/tags/lua.md>), [multi-tenancy](<https://devfeed.tech/tags/multi-tenancy.md>), [python](<https://devfeed.tech/tags/python.md>), [redis](<https://devfeed.tech/tags/redis.md>), [security](<https://devfeed.tech/tags/security.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

The article discusses multiple security vulnerabilities found and fixed in Redis's Lua subsystem, including issues in the cmsgpack and struct libraries. It explains that the vulnerabilities are especially relevant to cloud providers operating managed or multitenant Redis instances, while risk is more limited for users who control the data sent to their servers.

### Source excerpt

A bit more than one month ago I received an email from the Apple Information Security team. During an auditing the Apple team found a security issue in the Redis Lua subsystem, specifically in the cmsgpack library. The library is not part of Lua itself, it is an implementation of MessagePack I wrote myself. In the course of merging a pull request improving the feature set, a security issue was added. Later the same team found a new issue in the Lua struct library, again such library was not part of Lua itself, at least in the release of Lua we use: we just embedded the source code inside our Lua implementation in order to provide some functionality to the Lua interpreter that is available to Redis users. Then I found another issue in the same struct package, and later the Alibaba team found many other issues in cmsgpack and other code paths using the Lua API. In a short amount of time I was sitting on a pile of Lua related vulnerabilities. Those vulnerabilities are mostly relevant in the specific case of providing managed Redis severs on the cloud, because it is very unlikely that the vulnerabilities discovered can be used without direct access to the Redis server: many Redis users don't use the cmsgpack or the struct package at all, and who does will very unlikely feed them with untrusted input. However for cloud providers things are different: they have Redis instances, sometimes in multi tenancy setups, exposed to the user that subscribed for the service. She or he can send anything to such Redis instances, triggering the vulnerabilities, corrupting the memory, violating the Redis process, and potentially taking total control of the Redis process. For instance this simple Python program can crash Redis using one of the cmsgpack vunlerabilities [1]. [1] https://gist.github.com/antirez/82445fcbea6d9b19f97014cc6cc79f8a However from the point of view of normal Redis users that control what is sent to their instances, the risk is limited to feeding untrusted data to a

## Sandboxing landscape

DevFeed: [Sandboxing landscape](<https://devfeed.tech/articles/sandboxing-landscape-38962.md>)

Original publisher: [Read original article](<https://idea.popcount.org/2017-03-28-sandboxing-landscape>)

Author: Marek

Published: 2017-03-27T22:00:00Z

Content type: article

Language: en

Sources: [Marek Majkowski](<https://devfeed.tech/sources/marek-majkowski.md>)

Topics: [Security](<https://devfeed.tech/topics/security.md>), [virtualization](<https://devfeed.tech/topics/virtualization.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Process](<https://devfeed.tech/topics/process.md>)

Tags: [isolation](<https://devfeed.tech/tags/isolation.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [lua](<https://devfeed.tech/tags/lua.md>), [multi-tenancy](<https://devfeed.tech/tags/multi-tenancy.md>), [sandboxing](<https://devfeed.tech/tags/sandboxing.md>), [shouldn-t](<https://devfeed.tech/tags/shouldn-t.md>), [virtualization](<https://devfeed.tech/tags/virtualization.md>)

### AI overview

This article surveys four approaches to isolating untrusted third-party code: programming-language runtimes, operating-system processes, software fault isolation, and virtual machines. It discusses requirements such as multi-tenancy, scheduling, memory limits, and restricting privileged operations, then examines Lua and JavaScript as examples.

### Source excerpt

Sandboxing landscape Some time ago I started wondering - would it be possible for a CDN to run customer code on the edge servers? I read and asked around, over time I got acquainted to what is and what is not technically possible. But that didn't bring me closer to an useful answer. Fortunately exploring this subject has been enormous fun. In this blog post I'll describe my findings so far.

## Surviving Flashes of High-Write Traffic Using Scriptable Load Balancers (Part II)

DevFeed: [Surviving Flashes of High-Write Traffic Using Scriptable Load Balancers (Part II)](<https://devfeed.tech/articles/surviving-flashes-of-high-write-traffic-using-scriptable-load-balancers-part-ii-1633.md>)

Original publisher: [Read original article](<https://shopify.engineering/surviving-flashes-of-high-write-traffic-using-scriptable-load-balancers-part-ii>)

Author: Emil Stolarsky

Published: 2017-02-05T19:30:00Z

Content type: article

Language: en

Sources: [Shopify Engineering](<https://devfeed.tech/sources/shopify-engineering.md>), [Shopify Engineering - Shopify Engineering](<https://devfeed.tech/sources/shopify-engineering-shopify-engineering.md>)

Topics: [Shopify](<https://devfeed.tech/topics/shopify.md>), [Lua](<https://devfeed.tech/topics/lua.md>), [nginx](<https://devfeed.tech/topics/nginx.md>), [datacenter](<https://devfeed.tech/topics/datacenter.md>), [Code](<https://devfeed.tech/topics/code.md>), [Redis](<https://devfeed.tech/topics/redis.md>), [Replication](<https://devfeed.tech/topics/replication.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [data-center](<https://devfeed.tech/tags/data-center.md>), [database](<https://devfeed.tech/tags/database.md>), [load-balancer](<https://devfeed.tech/tags/load-balancer.md>), [lua](<https://devfeed.tech/tags/lua.md>), [nginx](<https://devfeed.tech/tags/nginx.md>), [redis](<https://devfeed.tech/tags/redis.md>), [replication](<https://devfeed.tech/tags/replication.md>), [shopify](<https://devfeed.tech/tags/shopify.md>)

### AI overview

Shopify describes a stateless approach to fairly prioritizing customers during flash-sale checkout traffic. Instead of relying on a database across multiple data centers, each load balancer calculates a queue threshold, while a securely signed cookie stores the customer's initial timestamp. High-priority users then pass through an existing leaky-bucket throttle.

### Source excerpt

7 minute read In the first post of this series, I outlined Shopify's history with flash sales, our move to Nginx and Lua to help manage traffic, and the initial attempt we made to throttle traffic that didn't account sufficiently for customer experience. We had underestimated the impact of not giving preference to customers who'd entered the queue at the beginning of the sale, and now we needed to find another way to protect the platform without ruining the customer experience.

## Redis Loadable Modules System

DevFeed: [Redis Loadable Modules System](<https://devfeed.tech/articles/redis-loadable-modules-system-20597.md>)

Original publisher: [Read original article](<http://antirez.com/news/106>)

Published: 2016-05-10T17:02:55Z

Content type: opinion

Language: en

Sources: [Antirez](<https://devfeed.tech/sources/antirez.md>)

Topics: [Redis](<https://devfeed.tech/topics/redis.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Scripting](<https://devfeed.tech/topics/scripting.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [lua](<https://devfeed.tech/tags/lua.md>), [modules](<https://devfeed.tech/tags/modules.md>), [programming](<https://devfeed.tech/tags/programming.md>), [redis](<https://devfeed.tech/tags/redis.md>), [scripting](<https://devfeed.tech/tags/scripting.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

The article discusses Redis loadable modules, explaining why the feature was delayed and outlining concerns about API incompatibility, system stability, ecosystem quality, and dependence on Redis internals. It contrasts modules with Lua scripting and describes a planned discussion of Redis's future roadmap.

### Source excerpt

It was a matter of time but it eventually happened. In the Redis 1.0 release notes, 7 years ago, I mentioned that one of the interesting features for the future was "loadable modules". I was really interested in such a feature back then, but over the years I became more and more skeptic about the idea of adding loadable modules in Redis. And probably for good reasons. Modules can be the most interesting feature of a system and the most problematic one at the same time: API incompatibilities between versions, low quality modules crashing the system, a lack of identity of a system that is extendible are possible problems. SO, for years, I managed to avoided adding modules to Redis, and Lua scripting was a good tool in order to delay their addition. At the same time, years of experience with scripting, demonstrated that scripting is a way to "compose" existing features, but not a way to extend the capabilities of a system towards use cases it was not designed to cover. Previous attempts at modules also showed that one of the main pain points about mixing Redis and loadable modules is the way modules are bound with the Redis core. In may ways Redis resembles more a programming language than a database. To extend Redis properly, the module needs to have access to the internal API of the system. Directly exporting the Redis core functions to modules creates huge problems: the module starts to depend on the internal details of Redis. If the Redis core evolves, the module needs to be rewritten. This creates either a fragile modules ecosystem or stops the evolution of the Redis core. Redis internals can't stop to evolve, nor the modules developers can keep modifying the module in order to stay updated with the internals (something that happened in certain popular systems in the past, with poor results). With all this lessons in mind, I was leaving Catania to fly to Tel Aviv, to have a meeting at Redis Labs to talk about the roadmap for the future months. One of the topics of

## Redis 3.2.0 is out!

DevFeed: [Redis 3.2.0 is out!](<https://devfeed.tech/articles/redis-3-2-0-is-out-20595.md>)

Original publisher: [Read original article](<http://antirez.com/news/104>)

Published: 2016-05-06T11:07:50Z

Content type: release

Language: en

Sources: [Antirez](<https://devfeed.tech/sources/antirez.md>)

Topics: [Redis](<https://devfeed.tech/topics/redis.md>), [API](<https://devfeed.tech/topics/api.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [debug](<https://devfeed.tech/topics/debug.md>), [Lua](<https://devfeed.tech/topics/lua.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [lua](<https://devfeed.tech/tags/lua.md>), [redis](<https://devfeed.tech/tags/redis.md>), [replication](<https://devfeed.tech/tags/replication.md>)

### AI overview

Redis 3.2.0 stable has been released with a GEO API, the BITFIELD command, Redis Cluster improvements, Lua script effects replication, a debugger integrated with redis-cli, and memory-efficiency changes.

### Source excerpt

It took more than expected, but finally we have it, Redis 3.2.0 stable is out with changes that may be useful to a big number of Redis users. At this point I covered the changes multiple time, but the big ones are: * The GEO API. Index whatever you want by latitude and longitude, and query by radius, with the same speed and easy of use of the other Redis data structures. Here you can find the API documentation: http://redis.io/commands/#geo. Thank you to Matt Stancliff for the initial implementation, that was reworked but is still at the core of the GEO API, and to the developers of ARDB for providing the geo indexing code that Matt used. * The new BITFIELD command allows to use a Redis string as a bit array composed of many integers with user specified size and offset. It supports increments and decrements to exploit this small (or large) integers as counters, with fine control over the overflow behavior. http://redis.io/commands/bitfield. Thanks to Yoav Steinberg for pushing forward this crazy idea and motivating me to write an implementation. * Many improvements to Redis Cluster, including rebalancing capabilities in redis-trib and better replicas migration. However support for NATted envrionments and Docker port forwarding, while implemented in the "unstable" branch, was not backported to 3.2 for maturity concerns. * Improvements to Lua scripts replication. It is now possible to use "effects replication" to write scripts containing side effects. It's documented here: http://redis.io/commands/EVAL. Thanks to Yossi Gottlieb for stimulating the addition of this feature and helping in the design. * We have now a serious Lua scripts debugger: https://www.youtube.com/watch?v=IMvRfStaoyM with support into redis-cli. Thanks to Itamar Haber, developer of non trivial scripts since the start of Lua scripting, that really wanted this feature and helped during the development. * Redis is now more memory efficient thanks to changes operated by Oran Agra to SDS and the Jemallo

## Recent improvements to Redis Lua scripting

DevFeed: [Recent improvements to Redis Lua scripting](<https://devfeed.tech/articles/recent-improvements-to-redis-lua-scripting-20688.md>)

Original publisher: [Read original article](<http://antirez.com/news/97>)

Published: 2015-11-19T11:23:27Z

Content type: article

Language: en

Sources: [Antirez](<https://devfeed.tech/sources/antirez.md>)

Topics: [Lua](<https://devfeed.tech/topics/lua.md>), [Redis](<https://devfeed.tech/topics/redis.md>), [Scripting](<https://devfeed.tech/topics/scripting.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [debugger](<https://devfeed.tech/tags/debugger.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [lua](<https://devfeed.tech/tags/lua.md>), [redis](<https://devfeed.tech/tags/redis.md>), [replication](<https://devfeed.tech/tags/replication.md>), [scripting](<https://devfeed.tech/tags/scripting.md>)

### AI overview

This article describes two improvements to Redis Lua scripting: a proper debugger and replication and AOF storage of scripts as the write commands representing their effects. It also discusses the design and implementation considerations behind these features.

### Source excerpt

Lua scripting is probably the most successful Redis feature, among the ones introduced when Redis was already pretty popular: no surprise that a few of the things users really want are about scripting. The following two features were suggested multiple times over the last two years, and many people tried to focus my attention into one or the other during the Redis developers meeting, a few weeks ago. 1. A proper debugger for Redis Lua scripts. 2. Replication, and storage on the AOF, of Lua scripts as a set of write commands materializing the *effects* of the script, instead of replicating the script itself as we normally do. The second feature is not just a matter of how scripts are replicated, but also touches what you can do with Lua scripting as we will see later. Back from London, I implemented both the features. This blog post describes both, giving a few hints about the design and implementation aspects that may be interesting for the readers. A proper Lua debugger --- Lua scripting was initially conceived in order to write really trivial scripts. Things like: if the key exists do this. A couple of lines in order to avoid bloating Redis with all the possible variations of commands. Of course users did a lot more with it, and started to write complex scripts: from quad-tree implementations to full featured messaging systems with non trivial semantics. Lua scripting makes Redis programmable, and usually programmers can't resist to programmable things. It helps that all the Lua scripts run using the same interpreter and are cached, so they are very fast. It is most of the time possible to do a lot more with a Redis instance by using Lua scripting, both functionally and in terms of operations per second. So complex scripts totally have their place today. We went from a very cold reception of the scripting feature (something as dynamic as a script sent to a database!), to mass usage, to writing complex scripts in a matter of a few years. However writing simple scri

## Teaching an LSTM to Play Beethoven

DevFeed: [Teaching an LSTM to Play Beethoven](<https://devfeed.tech/articles/teaching-an-lstm-to-play-beethoven-40104.md>)

Original publisher: [Read original article](<https://korbonits.com/blog/2015-07-01-lstm-beethoven/>)

Published: 2015-07-01T00:00:00Z

Content type: tutorial

Language: en

Sources: [Alex Korbonits](<https://devfeed.tech/sources/alex-korbonits.md>)

Topics: [MIDI](<https://devfeed.tech/topics/midi.md>), [Code](<https://devfeed.tech/topics/code.md>), [Lua](<https://devfeed.tech/topics/lua.md>), [GPU](<https://devfeed.tech/topics/gpu.md>)

Tags: [audio](<https://devfeed.tech/tags/audio.md>), [channel](<https://devfeed.tech/tags/channel.md>), [code](<https://devfeed.tech/tags/code.md>), [experiment](<https://devfeed.tech/tags/experiment.md>), [format](<https://devfeed.tech/tags/format.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [lstm](<https://devfeed.tech/tags/lstm.md>), [lua](<https://devfeed.tech/tags/lua.md>), [music](<https://devfeed.tech/tags/music.md>), [structure](<https://devfeed.tech/tags/structure.md>), [timing](<https://devfeed.tech/tags/timing.md>), [torch](<https://devfeed.tech/tags/torch.md>), [training](<https://devfeed.tech/tags/training.md>), [types](<https://devfeed.tech/tags/types.md>), [velocity](<https://devfeed.tech/tags/velocity.md>)

### AI overview

An experiment trains Karpathy's char-rnn LSTM on Beethoven piano sonata MIDI files, treating the raw MIDI bytes as a sequence. The author describes prepending a shared MIDI header to generated output so players could interpret it, and reports imperfect results containing occasional phrase-like and melodic fragments.

### Source excerpt

In June 2015, I trained Karpathy's char-rnn on a corpus of Beethoven piano sonata MIDI files. Here's what it sounds like -- and how I got it to play.

## Torch for Deep Learning Research

DevFeed: [Torch for Deep Learning Research](<https://devfeed.tech/articles/torch-bleeding-edge-dnn-research-40103.md>)

Original publisher: [Read original article](<https://korbonits.com/blog/2015-06-28-torch-bleeding-edge-dnn-research/>)

Published: 2015-06-28T11:49:40Z

Content type: tutorial

Language: en

Sources: [Alex Korbonits](<https://devfeed.tech/sources/alex-korbonits.md>)

Topics: [torch](<https://devfeed.tech/topics/torch.md>), [Deep learning](<https://devfeed.tech/topics/deep-learning.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [bash](<https://devfeed.tech/tags/bash.md>), [deep-learning](<https://devfeed.tech/tags/deep-learning.md>), [lua](<https://devfeed.tech/tags/lua.md>), [research](<https://devfeed.tech/tags/research.md>), [torch](<https://devfeed.tech/tags/torch.md>)

### AI overview

This article introduces Torch as a Lua-based deep learning framework and discusses its use for research, including its ecosystem, flexibility, installation, and relationship to Python.

### Source excerpt

An introduction to Torch, the deep learning framework favored by Facebook AI and Google DeepMind for cutting-edge research.

## How Side Projects Helped Sustain Redis Development

DevFeed: [How Side Projects Helped Sustain Redis Development](<https://devfeed.tech/articles/side-projects-20677.md>)

Original publisher: [Read original article](<http://antirez.com/news/86>)

Published: 2015-02-26T12:48:06Z

Content type: opinion

Language: en

Sources: [Antirez](<https://devfeed.tech/sources/antirez.md>)

Topics: [Redis](<https://devfeed.tech/topics/redis.md>), [Development](<https://devfeed.tech/topics/development.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Lua](<https://devfeed.tech/topics/lua.md>), [Git](<https://devfeed.tech/topics/git.md>)

Tags: [development](<https://devfeed.tech/tags/development.md>), [git](<https://devfeed.tech/tags/git.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [lua](<https://devfeed.tech/tags/lua.md>), [programming](<https://devfeed.tech/tags/programming.md>), [projects](<https://devfeed.tech/tags/projects.md>), [redis](<https://devfeed.tech/tags/redis.md>), [side-projects](<https://devfeed.tech/tags/side-projects.md>)

### AI overview

The author reflects on Redis's six-year development and describes maintaining a stream of side projects alongside it. These projects provided variety and renewed motivation, while some were incorporated into other people's code. The author says they were then spending about 20% of their time on Disque, a distributed message queue, and 80% on Redis.

### Source excerpt

Today Redis is six years old. This is an incredible accomplishment for me, because in the past I switched to the next thing much faster. There are things that lasted six years in my past, but not like Redis, where after so much time, I still focus most of my everyday energies into. How did I stopped doing new things to focus into an unique effort, drastically monopolizing my professional life? It was a too big sacrifice to do, for an human being with a limited life span. Fortunately I simply never did this, I never stopped doing new things. If I look back at those 6 years, it was an endless stream of side projects, sometimes related to Redis, sometimes not. 1) Load81, children programming environment. 2) Dump1090, software defined radio ADS-B decoder. 3) A Javascript ray tracer. 4) lua-cmsgpack, C implementation of msgpack for Lua. 5) linenoise line editing library. Used in Redis, but well, was not our top priority. 6) lamernews, Redis-based HN clone. 7) Gitan, a small Git web interface. 8) shapeme, images evolver using simulated annealing. 9) Disque, a distributed queue (work in progress right now). And there are much more throw-away projects not listed here. The interesting thing is that many of the projects listed above are not random hacking efforts that had as an unique goal to make me happy. A few found their way into other people's code. Because of the side projects, I was able to do different things when I was stressed and impoverished from doing again and again the same thing. I could later refocus on Redis, and find again the right motivations to have fun with it, because small projects are cool, but to work for years at a single project can provide more value for others in the long run. So currently I'm using something like 20% of my time to hack on Disque, a distributed message queue. So only 80% is left for Redis development, right? Wrong. The deal is between 80% of focus on Redis and 20% on something else, or 0% of focus on Redis in the long term, beca

## Learn X in Y Minutes: A Community-Editable Site for Inline Programming Language Primers

DevFeed: [Learn X in Y Minutes: A Community-Editable Site for Inline Programming Language Primers](<https://devfeed.tech/articles/learn-x-in-y-minutes-32142.md>)

Original publisher: [Read original article](<https://adambard.com/blog/learn-x-in-y-minutes/>)

Published: 2013-06-26T00:00:00Z

Content type: opinion

Language: en

Sources: [Adam Bard](<https://devfeed.tech/sources/adam-bard.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [Tutorial](<https://devfeed.tech/topics/tutorial.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Lua](<https://devfeed.tech/topics/lua.md>)

Tags: [also](<https://devfeed.tech/tags/also.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [github](<https://devfeed.tech/tags/github.md>), [lua](<https://devfeed.tech/tags/lua.md>)

### AI overview

The author announces Learn X in Y Minutes, a community-editable site for inline programming-language primers. It was seeded with Clojure and Lua tutorials, with plans for additional languages and contributions through GitHub pull requests.

### Source excerpt

Short version: Go to http://learnxinyminutes.com/ After I posted Learn Clojure in 15 minutes, perhaps yesterday, itself a knockoff of Tyler Neylon's Learn Lua in 15 minutes, I had a little twitter brainstorming session with Tyler and @emarref. Therein, I was inspired/encouraged to generalize the concept of inline tutorials-as-code language primers in a community-editable site.

## Lua as an Extension Scripting Language for Games

DevFeed: [Lua as an Extension Scripting Language for Games](<https://devfeed.tech/articles/hello-lua-40698.md>)

Original publisher: [Read original article](<https://radek.io/posts/hello-lua/>)

Published: 2011-08-11T00:00:00Z

Content type: opinion

Language: en

Sources: [Radek Pazdera](<https://devfeed.tech/sources/radek-pazdera.md>)

Topics: [Lua](<https://devfeed.tech/topics/lua.md>), [Scripting](<https://devfeed.tech/topics/scripting.md>), [coding](<https://devfeed.tech/topics/coding.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [game](<https://devfeed.tech/tags/game.md>), [lua](<https://devfeed.tech/tags/lua.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [scripting](<https://devfeed.tech/tags/scripting.md>)

### AI overview

The article introduces Lua as an open-source scripting language used by game developers to extend games and separate game content from engine code. It highlights Lua's C API, procedural syntax, bytecode-based virtual machine, dynamic typing, and incremental garbage collection.

### Source excerpt

I build software products and write on the Internet.