
Accepted Projects - Google Summer of Code 2015
- LuaRocks add-ons system
- Port Lua Test Suite to NetBSD Kernel
- Elasticsearch Lua client (elasticsearch-lua)
- Port an SDL-based C++ open source game to Céu
- Add support for WSDL generation to LuaSOAP
- Develop a binary serialization format with support for dynamically types values and an RPC protocol for dynamically typed invocations based on this format.
- Sailor: Web Development in Lua (proposed by the student)
LuaRocks add-ons system
Student
XIAO Qi - Technology University of Eindhoven, the Netherlands.
Mentor
Hisham Muhammad
Brief explanation
LuaRocks is a package manager for Lua modules. Since version 1.0, the format of the package specification file (rockspec) was unchanged, in the name of compatibility. For the next major release of LuaRocks, we intend to make a backward-compatible revision to the format. However, instead of guessing which features will be needed in the forthcoming years, the idea is to make the format extensible through add-ons, as discussed in this Lua Workshop 2014 talk.
There are two sides to making an application extensible: defining hooks to the application where extensions will plug into, and defining a public API, which is the parts of the application that the extensions will see/access.
This includes major design work, and the student is not expected to do this alone: the design part will be discussed with the mentor and the LuaRocks community at large through the LuaRocks mailing list. The coding part, of course, is up to the student.
The best way to evaluate new APIs is to put them to work: the second phase of the project will be to write some add-ons, to exercise the new features. Two features that are often requested by the community are support for running tests and generating documentation files: these would make great add-ons.
Expected results
- Extending the LuaRocks rockspec reader to allow new entries created by add-ons
- A system of hooks in LuaRocks to trigger actions programmed by add-ons
- A sandbox environment for presenting a restricted API to add-ons
- Add-ons for running tests and generating documentation
Port Lua Test Suite to NetBSD Kernel
Student
Guilherme Salazar - Universidade Federal de Goiás, Brasil.
Mentor
Lourival Vieira Neto
Brief explanation
The NetBSD Operating System has a kernel-level Lua interpreter version for scripting its kernel. For example, it allows users to filter packets using Lua scripts.
The main difference between kernel Lua and regular user-level Lua is that kernel Lua doesn't have support for standard libraries that depend on operating system (e.g., io and os) and for floating-point numbers. The purpose of this project is to port the Lua Test Suite to NetBSD kernel. That is, to adapt scripts from Lua test suite and develop a NetBSD loadable kernel module containing the C portion of Lua test suite.
Expected results
- Adapted test scripts for kernel Lua
- Kernel module for testing the Lua C API
Elasticsearch Lua client (elasticsearch-lua)
Student
Dhaval Kapil - Indian Institute of Technology Roorke, India.Mentor
Brief explanation
Elasticsearch is a distributed and scalable search engine. It is written in Java and, besides the transport protocol (Java to Java), it offers a very complete REST API accessed through JSON
Elasticsearch clients for different scripting languages such as Python, PHP and Perl have already been developed. However, a client for Lua is still not available.
This project aims to create a complete Lua client to access Elasticsearch.
Expected results
- A complete Lua client to access the Elasticsearch REST API.
Port an SDL-based C++ open source game to Céu
Student
Alexander Tkachev - Novosibirsk State Universit, Russia.Mentor
Francisco Sant'Anna
About Céu
Céu is a programming language that targets system-level development of reactive systems.
For a little introduction about the language, please watch the video in our front page:
http://ceu-lang.org/
Céu appeared last year on "StrangeLoop" and the "Future Programming Workshop":
http://www.future-programming.org/program.html
Brief explanation
Port to Céu an existing C++ open source game of considerable size (30-50k lines of code).Here are some possible projects to look for:
- http://en.wikipedia.org/wiki/List_of_open-source_video_games
- http://www.reddit.com/r/opensourcegames
Expected results
- A working implementation of the game
- A report about the experience of using Céu in the context of game development, also comparing the implementations in terms of code complexity (e.g., lines of code), resource usage (CPU, memory), etc.
Add support for WSDL generation to LuaSOAP
Student
Victor Dias - Pontifícia Universidade Católica do Rio de Janeiro (PUC-Rio), Brasil.Mentor
Tomás Guisasola
Brief explanation
LuaSOAP is a library to ease the use of SOAP. LuaSOAP provides a very simple API that convert Lua tables to and from XML documents. It also offers a simple way to invoke remote Web Services without having to deal directly with SOAP messages. In fact, LuaSOAP also provides a simple way to offer Web Services -- the server side -- but it lacks support for WSDL generation of the offered services.
WSDL is an XML format for describing network services. It is used to describe operations and messages -- with its types -- offered by Web Services. Since Lua code does not include type information, automatic generation has to be based on some kind of hand-made declarative information.
Expected results
- Define the format to describe complementary WSDL information in Lua
- Implement an automatic generator of WSDL documents
- Test and document everything
Develop a binary serialization format with support for dynamically types values and an RPC protocol for dynamically typed invocations based on this format.
Student
Lukas Borin - Chalmers University of Technology, Sweden.Mentor
Renato Maia
Brief explanation
Most RMI protocols available today are either focused on inefficient representation formats for typing information (e.g. GIOP/IIOP (CORBA), Hessian, Google Protocol Buffers) or on invocations where the typing information are predefined and static, therefore are absent on the data sent through the wire (e.g. SOAP, JSON, Burlap).
Few protocols are designed to work efficiently with typed data. Invocations with typed data work well with the RPC model because it allows the identification of deployment problems (mismatch interfaces) and facilitate the dynamic evolution of distributed systems. A protocol for dynamically typed RPC should be based on a efficient serialization format for typed data, that is, information about how the data should be interpreted.
The goal of this project is to design and implement a serialization binary serialization format with the following requirements:
- Primitive data: numeric formats (integer and floating-point), characters and boolean.
- Structured data: serialization of usual structured data like records, arrays, maps, tuples, union, etc.
- Optional typing: serialization of both raw data and data plus typing information.
- Structural compatibility: type information should allow to efficiently verify whether two types are compatibile.
- Opaque data: allow that a special form of raw data (without typing information) can be ignored without compromising the remains of the stream and that can also be passed along by a receiver that did not interpreted it.
- Semantic information: data types that can extend a standard type with additional semantic information, like a string (sequence of characteres) with an associated charset or a record with an associated class name that provides some behavior over the data on the record.
- Graphs: data with cyclic references.
Expected results
- An specification of a binary serialization format with support for typed data.
- An implementation of a library for encoding values using this format.
Sailor: Web Development in Lua (proposed by the student)
Student
Etiene Dalcol - Pontifícia Universidade Católica do Rio de Janeiro (PUC-Rio), Brasil / ENSTA Bretagne, France.Mentor
Fabio MascarenhasBrief explanation
Sailor is a web MVC framework completely written in Lua that allows to write robust web systems using the Lua programming language. It's in early development stage, with three releases under MIT License.Sailor currently runs on the top of various web servers, such as Apache2, NginX, Mongoose, Lwan and Xavante. It's compatible with different operational systems, such as Linux, Mac and Windows although Linux and Mac are more well-supported.
During GSoC 2015 the following improvements to Sailor will be developed:
- Development or Integration of a test suite to Sailor
- Improvements to the Lua programming environment at the client side
- DOM manipulation
- support for loading Lua modules