About the project
Modern software systems are getting increasingly more complex, especially distributed and decentralized systems. One of the significant consequences of this increase in complexity is a decrease in reliability. In turn, programs are having all kinds of undesirable properties, such as race conditions, information loss and security vulnerabilities.
State of the art approaches to managing the complexity in cloud-native software systems are mainly focused on container orchestration tools, such as Kubernetes, which attempt to hide the complex part of a software system from the programmer. However, the lack of transparency in such tools is often the cause of undesirable program behaviour rather than a remedy.
An alternative approach to managing software complexity is to look at the models that we use to build programming languages. Often, we do not need the full power of Turing completeness but can make do with a more restricted model. This, of course, poses the questions of how these models look and to what degree such restrictions can be made without removing the central properties that we want.
In this project, we will investigate the latter approach. To get a feel for the possibilities we will start by designing and investigating a simple toy programming language for a reversible distributed model. This model restricts information flow and provides the possibility for reverse execution, while not overly restricting Turing completeness. Precisely understanding what properties become decidable under the restriction will then aid the design and implementation of a more elaborate information preserving programming language. This in turn allows the implementation of more robust and reliable systems, which will then be founded in known theoretical models.