Student Thesis Topics (2023)

Teaching

I will supervise BSc thesis projects in Spring 2023. Since I have limited supervision capacity, I typically take the first N students following more or less a first-come, first-served strategy. I like to form clusters of students working on related topics, and I organize weekly (online) meetings with the clusters. We use a collaborative note taking tool to track progress. The work itself is taking place in two phases. In the first phase, students will dive into the state of the art of their topic, and they produce a state of the art report. I will review these reports and provide feedback. In the second phase, students focus on their own contribution, and they will finally write their thesis. The thesis naturally builds on the state of the art report and extends it with the work describing the contribution. Before submitting the thesis, students have to present and defend their work. The seminar grade is given for the presentation. The thesis grade is given for the thesis report, the technical accomplishments, including the work organization (regular participation in weekly meetings and steady progress).

If you are interested in systems-oriented computer science and computer security, either talk to me in person or schedule an online meeting. I expect that students have a solid understanding of operating systems and computer networks or computer security. I also expect that students are capable to handle programming tasks well and that they can work independently.

Embedded Operating Systems in Rust

The Rust programming language is actively being used in the context of embedded systems. Many projects have demonstrated that it is possible to write embedded software using Rust. The Tock operating systems is one of the more prominent embedded operating systems written in Rust. While the Tock kernel is written in Rust, the applications running on top of it are often written in C and not the Rust API, which is also available.

Potential topics in this space are

  • improvements of Rust usage in Tock applications,
  • development of educational material building on Tock,
  • porting Tock to new hardware components,
  • a security analysis of Tock code.

Reading:

Smart Homes and Home Automation Systems

Home automation systems are a fundamental part of smart homes. Many easy to deploy solutions are cloud based, which raises not only security and privacy concerns but also more general dependability concerns.

Potential topics in this space are

  • home automation solutions written in Rust (e.g., Homectl)
  • dependability and resilience analysis of home automation systems
  • designing resilient home automation systems from the ground up
  • creation of an experimental home (or office) automation system

Reading:

Sandboxed Code in the Linux Kernel (eBPF)

The Linux kernel supports the execution of sandboxed code inside the kernel that is provided by user-space programs. The eBPF technology has evolved significantly and can be used today in many different contexts. For example, eBPF programs supplied by user-space daemons can be used to distribute network connections to server processes accepting and handling the the client connections.

Potential topics in this space are

  • to design and prototype security application ideas using eBPF
  • an evaluation of Rust kernel modules versus eBPF modules written in Rust

Reading:

TLS Performance and Measurement Tools

TLS is used widely and usually implemented using libraries on top of the kernel's socket layer. Examples of TLS libraries are openssl, gnutls, or rustls. There are attempts to further optimize TLS implementations by moving TLS closer to the hardware. Examples are the kernel TLS implementation provided by Linux and FreeBSD. Some networking hardware cards further support the offloading of some of the TLS processing into hardware.

Potential topics in this space are

  • add (kernel) TLS support to iperf or rustls
  • performance evaluation of different TLS implementations

Reading:

Tracing and Visualizing Async Code Execution

Many modern programming languages support async functions where the execution of a fucntion may be sliced into multiple async code paths that are run by an executor. The Rust language provides support for defining async functions but leaves the executor to the runtime system. Hence, different executors may be used to run an async program. Async execution is harder to understand and for debugging and performance tuning purposes, it is useful to good tools that can record traces of async code execution and visualize it appropriately.

Potential topics in this space:

  • evaluation of existing tracing and visualization tools
  • improvements of existing tracing and visualization tools

Reading:

  • TBD

Extensions of the Lapce Code Editor

The Lightning-fast and Powerful Code Editor (Lapce) is an implementation of a code editor in Rust that resembles a bit some other popular code editors. While the editor itself is in a useable state, there are a number of extensions that can be contributed to help make this a full-fledged replacement of other code editors like Visual Studio Code.

Potential topics in this space are

  • development of additional plugins
  • collaborative editing (likely way too hard)

Reading:

Network Digital Twins

The concept of network digital twins gained some traction recently. The idea is to create a digital representation of a real-world communication network (the digital twin) that can be used for experimentation, for forecasting, or for trying out novel control algorithms that use machine learning approaches. As with every new concept, the are many different interpretations of the term and concept It is not entirely clear to what extend network digital twins are substantially different from traditional approaches to operate and manage networks.

Work in this space is likely more conceptual and hence may require a substantial amount of reading.

Reading: