Workshop 2011
Workshop 2011
The workshop is over. See some photos taken by Erik Hougaard and read a report by Tony Finch.
The Lua Workshop 2011 will be held in Frick, Switzerland on September 8–9, 2011.
As in previous workshops (2005, 2006, 2008, 2009), 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.
Please make your own travel and accommodation arrangements. Contact us if you need help or have special requirements.
Registration is now closed. See the list of participants.
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, including a social event with wine tasting of FiBL's organically grown wines.
See the final program and the abstracts.
The workshop will be held at FiBL, the Research Institute of Organic Farming, which is located near Frick in Switzerland, on a nice hillside between Basel and Zurich.
See Frick at Google Maps and learn how to get there.
Frick is well connected by train to Basel and Zurich. For information see the Swiss railway company.
There are two airports Basel and Zurich, which are both about one hour from Frick by public transportation.
EuroAirport, airport code BSL, Basel. This is the airport of Basel (CH), Mulhouse (F), and Freiburg (D). If you are arriving from France or Germany, then check if you can book a cheaper domestic flight. Easyjet has a base at the EuroAirport. They fly from many European destinations to Basel. There is a bus Line 50 that gets you every 15 minutes to the main railwaystation of Basel. There are several connections per hour to Frick, normally at xx:13, xx:20, xx:40.
Zurich Airport airport code ZRH, Zurich. This is a big international airport. Every hour from 06:04 to 21:04 there is a direct train from the airport to Frick.
We have reserved rooms in the Hotel Platanenhof, which is directly situated by the train station. The cost per night is CHF 140 (single) and CHF 200 (double), breakfast included. These are special conditions. The rooms are reserved until August 9th. You still need to make an individual reservation for your room.
To book a room send email to the hotel. Make sure to tell them that you are attending the Lua Workshop at FiBL. If you need an invoice, include your address.
We will have a shuttle from the Hotel Platanenhof to the workshop location.
There are three other hotels in Frick. A cheaper one is Hotel Rebstock. The rooms costs from CHF 68 to 98. Swiss prices already include tax.
The workshop is organized by Marc Balmer with Vera Hardmeier and the Lua team.
For further information, please contact the organizers:
email: vera at msys.ch, marc at msys.ch · voice: +41 61 383 05 10 · fax: +41 61 383 05 12
Some thorny points in the design of Lua: a personal perspective
slides
Roberto Ierusalimschy
(Lua.org, PUC-Rio)
The novelties of Lua 5.2
slides
Roberto Ierusalimschy
(Lua.org, PUC-Rio)
Reflexis Flow
slides
Ashwin Hirschi
(Reflexis)
In this presentation we will discuss how Lua has helped the team at Reflexis develop and evolve Reflexis Flow, a model-driven platform for web application development.
Since making software usually requires writing (and wrangling) lots of code, this talk will start by explaining how model-driven development tackles things differently. And as there are paradigms aplenty, it will present our particular take on it and why we feel Reflexis Flow provides people with an environment that makes it easy to create solutions for the web that are both flexible and secure.
Next we'll show how Lua has enabled the team at Reflexis to take somewhat of a middle ground between a procedural, component-based world view and a more high-level, model-driven mindset, resulting in a web application platform that's straight-forward to use but also easy to extend. While Flow developers don't need to be familiar with scripting, it is fair to say that knowing Lua greatly enhances what they can get out of our platform.
Last but not least, this talk will highlight several cases where Lua has really helped our team come up with practical solutions to specific problems. Time permitting we'll also demo some of our tools or a few of the projects completed using Reflexis Flow.
SPLAY
slides
Valerio Schiavoni
(Université de Neuchâtel)
SPLAY
simplifies the prototyping and development of large-scale distributed
applications and overlay networks. SPLAY covers the complete chain of
distributed system design, development and testing: from coding and local
runs to controlled deployment, experiment control and monitoring.
Developers specify their applications using Lua, which is executed in a
sandboxed environment. The talk will include
a short live demo of a simple distributed protocol in Lua deployed on the
PlanetLab.
SPLAY is the outcome of research and development activities at the Computer
Science Department of the University of Neuchatel, Switzerland.
d'Arc
Henning Diedrich
(Eonblast)
d'Arc offers an alternate and faster way to write C against both Lua and
LuaJIT. It is faster, can be easier to write and uses less memory in
many cases, than the the official API.
d'Arc can be used to make libraries for both Lua and LuaJIT faster, and
can make it less of a hassle to write patches that target both Lua and
LuaJIT. d'Arc allows you to use direct (cost-less) C pointers to
variable contents -- inside the universal Lua variable value holder C
structure -- in a clear and unified way.
After a brief historical intro, the talk will *primarily* take a closer
look at the Lua and LuaJIT VMs. I will inspect how iteration works with
the official Lua API and what happens 'under the hood', in both Lua and
LuaJIT. I will look at the similarities and the differences in the
implementation of the essential variable holder, TValue, in Lua and
LuaJIT. Continue with a look at where LuaJIT tweaks things right there
and how d'Arc allows you to write single source patches despite the
differences.
Finally, an easy example will be ported, from using the official API,
to using d'Arc. We'll compare how it simplifies the source, and make live
benchmarks to measure the difference, and look at pitfalls.
Lubyk: a Lua based ecosystem for live performances and distributed multimedia applications
slides
Gaspard Bucher
(lubyk.org)
The talk will highlight some unique aspects of Lubyk: plug & play
distributed computing and live coding by automagically connecting Lua
processes with ZeroMQ and ZeroConf. A short demo will use the
system to control the speaker's voice through simple body gestures (using a
wiimote probably) by sending OSC messages to Kyma. The second part will
be more Lua centric and highlight how lua scripts are connected together and
how their runtime environments are encapsulated to ease code reuse and avoid
side effects.
This will also be the occasion to release the first public beta for Lubyk.
Mitigating the danger of malicious bytecode
slides
Peter Cawley
(University of Oxford)
In Lua 5.1 and 5.2, the family of load functions permit the loading
of precompiled bytecode in addition to plain source code. We shall
look at some relevant details of the bytecode, and see how these
details can be maliciously abused to escape from a Lua sandbox (in
both 5.1 and 5.2). With the dangers presented, we shall then move to
look at two ways of mitigating them. Firstly, one can wrap the load
functions as to reject bytecode before it is loaded. Secondly, and
more interestingly, one can attempt to algorithmically decide whether
a given piece of bytecode is malicious or not. We shall look at two
such algorithms for validating bytecode: LBCV, which tries to
reject as little as possible, and my current experimental verifier,
which tries to accept as little as possible.
LuaDura for Olivetti
Patrick Rapin
(Olivetti Engineering SA)
Olivetti is active in the ink-jet printing industry. Our current
prototyping and testing platform is called LuaDura, based on Lua.
The talk will first expose its origins (including its strange name),
and the underlying concepts.
For better comprehension, a rapid look into the foundations of
Olivetti printers firmware will be necessary.
Then we will see some implementation decisions, and some special
features like the "threads" built upon coroutines and native threads
together.
The last part of the talk will be about how the application is used at
Olivetti by lots of various people.
But also what are the mostly experimented problems.
If there is time,
the presentation will finish with a small demo of "midi.lua".
IceLuva: a Lua-based framework for Magnetic Resonance Image reconstruction
Francesco Santini
(University of Basel Hospital - Radiological Physics)
The reconstruction of images acquired with Magnetic Resonance involves
many different manipulation steps, dealing with real and complex data.
In this work, a brief overview of how a clinical MR scanner deals with
data acquisition and image reconstruction will be given, introducing the
tools that are generally available to the researcher for the
customization of this process. Subsequently, the IceLuva framework is
introduced.
This framework is designed for postprocessing of the (complex) images, a
step that is usually performed on a separate computer with tools like
matlab. IceLuva is implemented as a functor in the reconstruction
pipeline of the scanner, including a Lua virtual machine and the
appropriate bindings for retrieval and storage of images. Details of the
integration will be given in the talk.
Finally, some custom extensions to the original Lua language, for basic
image and complex data manipulation, are implemented in order to
simplify common operations.
In the end, real-life examples of usage will be given and a performance
comparison between Lua interpreter, LuaJIT and offline Matlab processing
will be presented.
Lua/APR: An extended standard library for Lua
slides
Peter Odding
(Netherlands)
Lua is a very elegant programming language, both because of its
conceptual simplicity and the small size of its implementation, but this
small size comes with a price: Lua's operating system interfaces are
quite minimal and (in a sense) this makes Lua a second-class citizen on
popular platforms like Windows and UNIX systems.
In this presentation the author will talk about Lua/APR, a binding of
the Apache Portable Runtime (APR) for Lua. The talk will start with the
author's motivation for creating the binding, followed by a short
introduction to APR and its origins. Next a short summary of the
available operating system interfaces will be given. After this the
technical challenges in creating the binding will be discussed. Finally
the author will share his master plan in creating Lua/APR :-)
Lua tooling for M2M & embedded development / Koneki Project
Fabien Fleutot
(Sierra Wireless)
Lua's flexibility makes it very versatile, but also makes it harder to
provide good IDE support for it.
Koneki is an Eclipse technology project aiming at proposing advanced tooling
to help M2M (machine-to-machine) developers to create their solution.
The proposed talk aims at highlighting the noteworthy features of Lua
tooling in Koneki, in particular the support for LuaRocks and LuaDoc ; as
well as giving the attendees an overview of a couple of design decisions
which are allowing us to propose extensible tooling, in particular because
most of the actual parsing code is written in (Meta)Lua.
Lua for M2M (machine-to-machine) communications
slides
Fabien Fleutot
(Sierra Wireless)
We develop a software agent, running on various embedded devices, which
allows to monitor and control them through the net. A large part of the
embedded code is written in Lua, which offers interesting solutions to many
of our problems. Among noteworthy technologies we consider presenting, we
have:
coroutine-based scheduling, which allows most of our code to run
unmodified on Linux-based systems as well as OS-less, callback driven
architectures;
a widespread use of ltn12 to handle data streams (IPC as well as
client/server communications, mostly based on Hessian);
some modifications in the Lua bytecode format which allows to keep large
parts of Lua code in flash, thus saving significant amounts of RAM;
an application-generation wizard, which offers flexibility for unforeseen
needs (by allowing to add arbitrary Lua code), and allows to provision
generated applications on architectures which would normally only accept a
single monolithic executable.
Declarative Internal DSLs in Lua: a game-changing experience
slides
Alexander Gladysh
(LogicEditor.com)
This talk will cover an approach to implementation of internal
declarative DSLs in Lua, developed by the author along with the team.
The approach employs a format-agnostic loader for a declarative DSLs
and several DSL data-handling idioms, all described in the talk.
Described approach is used widely in author's and team's work, and
proven to be game-changing to our Lua application development process.
It significantly eased and streamlined our work with DSLs, leading to
the boom of effective DSL-driven solutions (also briefly showcased in
the talk).
The Quest API for Gbanga
Robin Di Capua
(Millform AG)
I'll talk about how we implemented our Quest API in
Lua to create fast and easy to extend scripts for our location based
platform Gbanga. I'll show some examples of Lua scripts and how we used
them to dynamically populate our virtual world in our game Gbanga: Famiglia.
Crazy Ivan, a Lua driven robot
Erik Hougaard
(E Foqus Danmark A/S)
For the last 11 years, a competitor in the Danish robotic race "DTU
RoboCup" has been a Lua driven robot called 'Crazy Ivan'. Crazy Ivan is
one of the most successful robots in the competition. The Crazy Ivan
robot is designed to drive through a predefined race track and solve
different tasks such as climbing stairs, passing a guillotine, playing
golf and much more. Lua is used as the programming language for the
robot's "brain" and all decisions are taken in Lua. This is the fourth
incarnation of the robot, now vision based. During the presentation,
Crazy Ivan will be running live on the floor while its "Master"
will try to control the action. Anything can—and will—happen!
Interface specification and verification
slides
Wim Couwenberg
(Océ)
I will present an example of how Lua is used as a support tool in
our build and automatic testing framework. Our software consists of
many components that communicate via interfaces that are defined in a
(proprietary) idl. Interface traces for each component are saved during
each run of our software. These trace files are handled by Lua scripts
to decode them into a readable format and to perform specialized post
mortem analysis on them. Recently I added the possibilty to specify
interface behaviour directly into the idl as small Lua snippets. This
invites developers to properly document their interfaces and at the
same time relieves them of the burden to write analysis scripts per
component.
Lua in the NetBSD Kernel
Marc Balmer
(micro systems)