Internship 2024–2025: A Kubernetes-based backend for the Varda distributed programming language

Keywords

Distributed systems; distributed programming; programming languages; code generation.

Background

Distributed systems are increasingly widespread and critical. A typical distributed system composes independent modules, which execute concurrently and communicate with one another through message-based APIs. This modular approach promotes software reuse, flexibility, and independent execution. However, understanding the behavior of a composition is hard, because of concurrency, failures, and weak guarantees (such as type checking).

The Varda distributed programming language aims to leverage the power of distributed computing and the strengths of modularity, reconciling strong abstractions and performance. Varda helps the developer reason about components both individually and in composition, while preserving performance and programmer control.

A Varda program specifies a system as an architecture of independently-developed components. Each component has a well-specified protocol interface and high-level safety constraints, while Varda orchestration specifies how components are created and destroyed, where they are located, how they interact, and what invariants they must maintain. A Varda system can be re-architected flexibly thanks to transparent interception.

The Varda compiler verifies component interactions, and generates glue code between modules and with the environment. The compiler is highly modular, provides extension hooks, and can support multiple code-generation backends. The current backend generates code for a Akka-based actor runtime library.

Internship perspectives

Varda supports lightweight but strong abstractions, which are designed to have low overhead and to not come at the expense of performance, placement control and elasticity. The current backend generates Java code for a Akka-based actor runtime library. Runtime performance is not satisfactory.

The goal of the internship is to develop an alternative backend and an associated runtime environment with improved performance and flexibility. It will be based on Kubernetes, using the Go language. The intern will gain working knowledge of the Go language and of Kubernetes, and will advance the state of the art of distributed systems and distributed languages.

Requirements and application

The internship will be advised by Alessio Pagliari of Sorbonne-Université, by Marc Shapiro of Sorbonne-Université and Inria, and by Ahmed Bouajjani, of IRIF. It will take place in Paris, France. Speaking French is not required.

The candidate should ideally be familiar with compilation and have some knowledge about distributed system.

The candidate should also have a basic experience in software programming in OCaml and usage of collaborative tools such as git.

Please contact the advisors Marc Shapiro <marc.shapiro@acm.org> and Alessio Pagliari <alessio.pagliari@lip6.fr>, with the following information:

• A resume or Curriculum Vitæ.
• A motivation letter.
• A list of courses and grades of the last two years of study (an informal transcript is OK).