Student Projects

Are you interested in a semester/master project at LAMP? Here are potential projects that we have thought of. However, feel free to contact us about your own ideas as well.

Most of the following projects are related to Dotty, which is the next-generation Scala compiler, developed in the lab, and slated to become Scala 3.

Interpolator macros

Type: bachelor semester project, master semester project, master thesis project
Major: computer science, communication systems, data science
Supervisor: Aggelos BiboudisNicolas Stucki
Students: 1-2

Scala 3 will have a new macro system that fundamentally changes the API for macro writers. The new system is better grounded in theory but will require new techniques to be developed for macro writers.

An important area of macros are string interpolators. These are used for many different use cases, from formatted output, to XML trees, to database query languages. The purpose of this project is to develop macros for some fundamental interpolators.

Depending on experience and number of students, the project is suitable for one or two bachelor students, a master student, or even a master thesis. If it’s a master thesis we would hope to see some fundamental work on how query languages can be embedded in programming languages.

Getting started:

FSM-like protocol checking for Scala

Type: master thesis project
Major: computer science, communication systems, data science
Supervisor: Fengyun Liu
Students: 1

In programming, there is often the need to enforce some protocol on how we interact with an object. For example, for a file, we need to call “open” first, then it can be “read” many times. In the end, we must call “close”. Any violation of the protocol will result in errors. There has been rich studies of these behavioral properties in the form of linear types [1], session types [2] and typestates [3]. Most of the approaches are based on types. We take a different approach that is based on verification. Some initial design idea can be found here.

Key challenges are the following:
(1) how to deal with aliasing,
(2) how to support higher-order functions,
(3) how to deal with inheritance,
(4) how to synchronize static & dynamic states, and
(5) how to make it practical for real-world Scala programming.

[1] Bernardy, J et al. “Linear Haskell: practical linearity in a higher-order polymorphic language.” PACMPL 2 (2017): 5:1-5:29.
[2] Honda, Kohei et al. “Multiparty asynchronous session types.” POPL (2008).
[3] Bierhoff, Kevin and Jonathan Aldrich. “Modular typestate checking of aliased objects.” OOPSLA (2007).

[PROJECT NOT AVAILABLE ANYMORE] Automation, monitoring and data analysis for the Scala MOOCs and EPFL courses

Type: bachelor semester project, master semester project, master thesis project
Major: computer science, communication systems, data science
Supervisor: Guillaume Martres
Students: 1

LAMP is responsible for teaching several Scala courses at EPFL, part of these courses are also available online as MOOCs on coursera and courseware.epfl.ch where a large number of students take them. We already have some infrastructure to handle this, but to improve the courses and the Scala language itself, we’d like to do much more, here are some challenges that you could work on as a semester project or a master thesis depending on the complexity of what will be done:

(1) Assignment are graded automatically on one of our servers, but the logs of this server have to be checked manually to detect problems, can we make grading more robust against errors, and add an alert system to let us know about potential problems ?

(2) Can we do data analysis on the code submitted by students to find interesting patterns such as common source of errors ?

(3) When students enable telemetry in the IDE, we get data on everything they type, and how the compiler reacted to it. By analyzing this data (either manually, through a good user interface, or automatically using machine learning) we may be able to learn a lot about how people learn Scala, as well as find bugs in the IDE support.

(4) And more, ideas welcome! For example, imagine having a Recurrent Neural Network where the data is students’ code and IDE interactions.

A Tasty Interpreter for Scala

Type: master thesis project
Major: computer science, communication systems, data science
Supervisor: Nicolas Stucki Sébastien Doeraene
Students: 1

The goal of the project is to implement an interpreter for Scala based on Tasty. Tasty [1] is the standard immediate representation of Scala programs. Most Scala programs depend on classes defined in JDK, a challenge is how to deal with those dependencies. To alleviate the interop problem, we will develop the interpreter on top of Scala.js [2], which has an implementation of the most commonly used classes of JDK in Scala, and whose interop semantics with JavaScript is well-defined. The evaluation of the project will be whether the interpreter can successfully interpret all the run tests in the Dotty compiler.

[1] Tasty format
[2] https://www.scala-js.org/

Reimplementing a dependently typed program in Dotty

Type: bachelor semester project, master semester project, master thesis project
Major: computer science, communication systems, data science
Supervisor: Olivier Blanvillain
Students: 1-2

Dotty has experimental support for a restricted form of dependent types. The goal of this project is to showcase the expressibility and limitations of our current solution by reimplementing the functionality of a medium scale dependently program in Dotty.

The starting point could be either an existing Idris library, or a paper describing a library implemented using dependent types in any dependently typed language. We are interested in programs that combine both interesting compile type checks and actual run-times.

Implement a documentation tool for Dotty using Tasty

Type: master semester project
Major: computer science, communication systems, data science
Supervisor: Aleksander Boruch-Gruszecki
Students: 1

We need a reliable, maintainable tool for generating documentation of Dotty code. Current tooling for both Dotty and Scala is tightly integrated with the compiler and simply not up to the standard we’d expect.

Dotty generates Tasty [1] files in addition to bytecode. The Tasty files are intended to be an easily consumable format containing most of the information about code that the compiler knows, including sub- and supertypes of all classes and their documentation comments.

As such, the documentation tool should take the Tasty files as input and generate documentation in a machine-readable format that can be rendered to HTML, such as reStructuredText [2] – researching what format to use is part of the project. As a minimum, we want to support all the functionality that scaladoc [3] already supports.

[1] Tasty Format
[2] reStructuredText
[3] Scaladoc