Lua: workshop 2013

The Lua Workshop 2013 will be held in Toulouse, France, on November 23–24, 2013. It will be part of Le Capitole du Libre, a larger FOSS event.

As in previous workshops (2005, 2006, 2008, 2009, 2011, 2012), the main goal of the workshop is to allow the Lua community to get together and meet in person and talk about the Lua language, its uses, and its implementation.

The workshop is open to everyone interested in Lua. There is no registration fee but participants are required to register because space is limited.

Please make your own travel and accommodation arrangements. Contact us if you need help or have special requirements.

Registration

If you have sent a registration, but your name is not listed, please let us know.

Program

We shall have a plenary talk by Roberto Ierusalimschy (Lua's chief architect) and several contributed talks. There will also be plenty of time for getting together and chatting about Lua.

All activities in the workshop will be conducted in English. Other activities in Captiole du Libre are mainly in French.

This event will be composed of talks, all Saturday 23rd and Sunday 24th morning. For the Sunday afternoon, it would be great to have more interactive workshops, since the Sunday is usually more of a general public event.

If you'd like to speak at the workshop, please send a title and a short abstract to the organizers.

The final program is shown below but it is still subject to last-minute changes.

Venue

Travel

By rail

Toulouse train station is Toulouse Matabiau. You may want to buy tickets from Captaine train. The train station is a 20-minute walk from ENSEEIHT. You can also use the subway from the train station: On line A, heading to Basso Combo, take line B at Jean Jaurès. Leave at François Verdier. Now you are 5 minutes away from ENSEEIHT. Here is a map.

By plane

The nearest airport is Toulouse Blagnac. There are flights from Paris every 30 minutes and direct flights from numerous cities. To reach ENSEEIHT from the airport, take the Tisséo's Airport shuttle, leave at Jean Jaurès, then follow this map.

Accommodation

There are many hotels downtown, prices starting at 50€. Hostels with prices starting at 17€.

Within a 5-minute walk from ENSEEIHT, Kyriad Toulouse Centre is probably the most practical hotel.

You can also contact toulouse-ll to find whether a FOSS user could host you for the occasion.

Organization

Participants

Abstracts

Integrating Lua into the high-end automation framework McRobot slides video
Thomas Jericke (Indel AG)

McRobot is a module and message based framework for automation. It is used to control various types of machines, such as handling systems, pick and place (SMT) and wire processing machines. This talk will show several aspect of integrating Lua into an existing framework as its primary scripting language. It focuses on the following topics:

Binding Lua with a message based framework
Writing a custom scheduler for Lua in C
Adding debugging support with Eclipse as IDE
Building a cross-compiler library for Lua source code to embedded Lua bytecode

Gitano and its attendant technologies slides video
Daniel Silverstone (Codethink Ltd.)

I will cover the Gitano Git Service (written in Lua) and its attendant technologies:

Lace - Lua Access Control Engine
Clod - Configuration Language Organised (by) Dots
Supple - Sandbox (for) Untrusted Procedure Partitioning (in) Lua - Engine
Gall - Git Abstraction layer (for) Lua
Gitano - A Git Service written in Lua

I will cover the issues encountered and resolved while writing Gitano, some of the current uses of Gitano, and some of the future plans for the technology.

A visual DSL toolkit in Lua: past, present and future slides video
Alexander Gladysh (LogicEditor)

Lua, besides its other virtues, is quite easy to learn. Nevertheless, Lua is a programming language, and in order to learn it one must invest a considerable effort to learn to write programs. It is often the case that, on one hand, there is a need to configure lots and lots of business logic intricate and ever-changing rules, but, on the other hand, the person who has the most expertise on the particular business logic area – domain expert – not have any clue on how to write code effectively (or even at all). All kinds of clumsy UIs, spaghetti code, wasted dedicated scripter's hours and other unpleasantries stem from that problem. Our flagship product – Business logic editor toolkit – to alleviate that somewhat by providing a programmer with a set of tools to easily build a business-logic configuration UI, suitable for a non-programmer domain expert, and an easy, platform-agnostic way to seamlessly tie business-logic configuration from that UI to an existing (or newly written) codebase, effectively creating a visual domain-specific programming language. Our toolkit is written in Lua (and some JavaScript), and it is a seventh generation implementation of the concept behind it. In this talk I'll talk a little about the past generations, describe the mechanics behind the current implementation in some detail, and I'll share our thoughts on how the next generation should look like – a new approach on the internal DSL design in Lua. And a promise: no marketing speak in the talk, and as much technical details as I'd dare (and time will permit)!

Using Lua to boost document handling and information retrieval in XML Native Database scenarios slides video
Valerio Capoccia and Roberto Tirabassi (3D Informatica Srl)

Our primary target was integrate a scripting language to delegate specific operation on data to something else than the engine. The specific target, required very intimate integration with a multitude of features Document/Object Oriented belonging to the engine and at the same time a great simplicity and flexibility of development. By placing the look at the panorama of scripting languages that could lend themselves for this purpose, whereas the integration would take place with modules fully implemented in C/C++, Lua language has soon proved our right choice. It is widespread and is used in many different areas. It has a wide extensibility as well a wide range of functionality and libraries already available, and is designed to suit a multitude of our needs. In its declination LuaJIT, also offers a level of performance further advanced. Our implementation of Lua in eXtraWay provides an executor of scripts, organized into packages in java style, which can be invoked explicitly (Stored Procedures) or run automatically inside the engine(Triggers) and who are able to take advantage each other through a simple inclusion system. We have developed specific packages for individual databases eXtraWay in which it was necessary to carry out specific and tricky operations on documents and indices. Were also developed generic library to perform common operations on documents through Lua, reusable in multiple scenarios. Each package refers to a dynamic library specifically designed allowing you to use the functionality of the server invocandole directly from Lua scripts built. so you can create records, save them, search them, operate on lists of records and their abstract, load the XML content and perform multiple operations on the same structure including managing digital content associated with them. You can also perform batch external and different solutions have been implemented for the management of large amounts of data in memory and on file.

This is a talk on LuaRocks, the package manager for Lua modules. LuaRocks was first released in 2007 and currently features over 300 projects in its repository. The focus of the talk will be on the history of LuaRocks so far, its current status and latest developments, including possibilities for changes, especially revisions in the rockspec format. The idea is to hopefully open a discussion with the community with regard to future directions. (An accompanying article on the history of LuaRocks is available.)

We will have a look the Lua ecosystem, comparing it to that of other dynamic programming languages. We will try to understand what makes its specificity and what we, members of the community, can do if we want to increase the popularity of the language. We will particularly focus on Open Source libraries.

Using Lua for BACnet OEM solutions in building automation slides video
Robert Schlephorst (SE-Elektronic GmbH)

In order to create highly customizable BACnet OEM solutions we integrated a Lua runtime into our building controllers. From within this runtime you have access to our BACnet stack (ASHRAE/ANSI 135-2010; ISO 16484-5) and can interact with internal and external BACnet objects and devices. Each Lua instance is part of the BACnet stack itself and can be controlled with the BACnet protocol. Furthermore, it is possible to use Lua for diagnostics, tests and one-time tasks since each instance is equipped with shell access via telnet.

CFM: A Console File Manager for POSIX slides video
Joseph Manning (University College Cork)

CFM is a text-based file manager for POSIX-compatible systems, written in just 750 lines of Lua, using the 'posix' and 'curses' libraries. CFM emphasises a clean uncluttered display and simple ergonomic interaction, while providing a good range of useful facilities. This talk firstly demonstrates the features of CFM and then presents several observations on the use and advantages of Lua in developing this software.

Using Lua for Responsive Programming of iOS apps slides video
Jean-Luc Jumpertz (Celedev)

Celedev has developed a live-coding-oriented development environment for iOS apps. This talk will be focused on the role of Lua as a key component of this system. It will present the reasons behind the choice of Lua and will discuss several technical aspects of the integration of Lua in a complex host operating system like iOS, including:

Multi-threading aspects: We will see why multi-threaded Lua is a mandatory feature in our system and we will show how to use the lua_newthread() function to run code from multiple threads within a standard Lua VM. We'll also provide a few implementation tips & tricks to avoid common traps in Lua multi-threaded implementation.
Object-Oriented framework: The need for integration of Lua code with the iOS Objective C runtime has led us to design an extensive Lua Objects Framework, fully compatible with the Objective C model, but with a very Lua-ish spirit; we will give a brief overview of this framework.
Dynamic code update: we will discuss Celedev dynamic code update feature from the Lua implementation perspective and show how it is integrated with the Lua require() function.
Lua Debugger: And, as a good debugger is key for serious software development, we will put the highlight on some original features of the Celedev debugger and show the debugger integration with other features of the system discussed previously.

This talk will be illustrated by short coding & debugging demos of the Celedev Responsive Programming system on iOS devices.

Recently I have been working on a project (called "ljsyscall") to experiment with scripting operating systems in Lua. In this talk I will look at progress so far, what I have learned, and look at a roadmap towards an operating system that is scriptable entirely in Lua. Initially ljsyscall was an experiment to see what a scripting interface for Linux would look like in Lua. I started with system calls, and progress was slow, as there are lots of them and you cannot do very much with just a few. But I carried on, and then started adding facilities built on the raw system calls, such as configuration of network interfaces, security systems etc. The aim was to get to the point where an application could easily configure its whole runtime environment without needing a large infrastructure of shell scripts etc. It was partly driven by the way that the way systems boot was being made less transparent by code such as systemd which moves code into C not shell, making it harder to understand how an operating system works, while one that works in Lua should be easier to understand. The second phase, in 2013, involved more experiments, this time with NetBSD, and the NetBSD rump kernel, which allows parts of NetBSD, such as file systems and the network stack, to run in userspace, even in other operating systems, or in systems with no operating system at all such as embedded systems. Lua scripting was extended to be able to script these, with the same interface as on the operating system itself. This allowed things like booting Lua natively as a guest under Xen, without an operating system at all but with a full network stack and file system, in a couple of megabytes. Future work includes further work with NetBSD, as Lua is now a component in the core set of packages in the operating system, although it is not yet used there. NetBSD is a good complement to Lua, as it is small, portable and powerful. I intend to work towards producing a scripting interface for all the core functionality, in what will be a fruitful partnership. Other work in progress is the port of ljsyscall from LuaJIT that it originally targetted to PUC Lua, and further extensions for Linux.

LuaDist: providing the batteries slides video
Peter Drahos (Slovak University of Technology, Faculty of Informatics and Information Technologies)

One of the primary issues with Lua in the wild is the lack of standardized batteries included distribution. Creating and maintaining a distribution that is as portable and flexible as Lua is challenging, especially for modules that depend on external libraries. Solutions to this problem are partially available in form of the LuaRocks and LuaDist projects, however there are still some standing issues that have to be addressed. This talk will summarize the challenges of building multi-platform Lua distributions and provide some insight into the planned unification between the two most prominent package management systems in the Lua ecosystem.

Integrating Lua in a commercial product - Experiences made and decisions taken video
Marc Balmer (micro systems)

arcapos is a commercial point of sale solution for retail and ticketing with a focus on ease of use, speed, and stability. The frontend can be extended using the Lua language, the backoffice parts are written to 90% in Lua. With integrating Lua we had two things in mind: Allow us to quickly react to customer requests, and, allow experienced users and resellers to change the system. This is a (technical) talk about how we integrated Lua into the arcapos point of sale solution. This is not a marketing talk, of course, but rather technical issues we faced, how we solved them, code examples (both C and Lua) etc.

The Web is the biggest platform in the world and it can now be scripted in Lua. Anything that has been created in JavaScript can be created using Lua too, with the help of a lightweight virtual machine called Moonshine. In this talk I'll introduce Moonshine and walk you through how to get started with Lua in the browser. We'll write some code, create some APIs, explore the debugger and discover a few things that are now possible with Lua and the Web.

LuaNode allows to write performant net servers or clients, using an asynchronous model of computing (the Reactor pattern). You might have seen this model implemented in event processing frameworks like Node.js, EventMachine or Twisted. In fact, LuaNode is heavily based on Node.js.

Towards practical type-checking for Lua slides video
Fabien Fleutot (Sierra Wireless)

This talk will describe ongoing investigations to perform optional, partial, compile-time type-checking on Lua programs. It describes the main challenges and compromizes necessary to go from a theoretically sound type system to a pragmatic solution, finding actual bugs in actual programs without requiring excessive amounts of bookkeeping from developers.

Debian is a free OS distribution on which more than 120 derivatives are based. It distributes around 20K different softwares, precompiled and packaged for an average of 10 architectures. Lua is part of it, and the 5.1 runtime counts more than 100K installations (in Debian, 10 times more in Ubuntu, ...). In this talk I describe how Lua fits in this picture, and how the peculiarities of Lua make it easy or hard to package it and its libraries for a mainstream software distribution like Debian.

Lua is part of the NetBSD operating system. It is not only used to script programs in userspace, but also to run Lua code in kernel space. What sounds bold at first sight allows for interesting experiments, e.g. rapid system code development, ideal for prototypes, proof of concepts and such. In this talk, I'll give an overview of the current state of Lua in NetBSD, the components and NetBSD specific bindings, and what generally can be done using the NetBSD and Lua combination.