logo of the SSW institute ;)
Computer Science
System Software




PhD Theses
Go Abroad



Open Projects

For Bachelor's theses or for Software Engineering projects in the Master's program

(Some of these topics can also be extended for a Master's thesis. Please ask.)

  • Automatic Evaluation of C Bug Finding Tools
    Buffer overflow vulnerabilities, use-after-free errors, NULL dereferences, and other errors are omnipresent in C. Bug-finding tools such as LLVM's AddressSanitizer, Valgrind, and Safe Sulong enable programmers to tackle this issue by executing the system under test with the respective tool. The goal of this project is to automatically determine the distribution of error categories and evaluate state-of-the-art bug-finding tools on Github projects. The outcome should be a tool that downloads projects from Github, builds the projects, and runs their test suites with different bug finding tools. The bug finding tools must be capable of classifying execution errors by their error messages.

  • A Feasibility Study on Executing Binary Code on Sulong
    Sulong is an execution environment for C and other low-level languages on the JVM. C programs often rely on third party libraries that are only available as binary code, which cannot be executed by Sulong. However, Sulong executes a low-level intermediate representation, called LLVM IR, that can be produced by tools from binary code. Such tools include QEMU, MC-Semantics, and LLBT; using one could enable Sulong to execute binary code. The goal of this project is to evaluate whether these tools are complete enough to translate common code and determine if the produced LLVM IR is suitable for execution on Sulong. As a subgoal, unimplemented features that are exercised by such code should be implemented in Sulong.

  • Running a C Standard Library on Sulong
    Sulong is an execution environment for C and other low-level languages on the JVM. C programs typically use the C standard library to perform common tasks such as string manipulation, memory management and I/O. The goal of this project is to run an existing libc (such as musl libc) on Sulong. Likely, bugs in Sulong (and potentially in the libc) will be found that should be fixed or documented.

  • Graal Collections (Graal and Truffle)
    Graal is a just-in-time compiler for the JVM platform that is itself written in Java. Graal's code base makes heavy use of Java Collections such as List, Map and Set with their standard JDK implementations ArrayList, HashMap and HashSet. Using the standard JDK container implementations has certain disadvantages. The goal of this project is to implement a specific Graal collection type, e.g., the List interface that is optimized for run-time and memory efficiency as well as for the usage patterns in Graal.

  • Architekturanalyse reaktive Systemplattform bei CELUM GmbH
    CELUM GmbH (http://www.celum.com) ist ein führender Hersteller von Digital Asset Management Systemen. In einem aktuellen Forschungsprojekt soll eine neue Kollaborations-Lösung aufgebaut werden, mit der die Erstellung von digitalen Inhalten in weltweit verteilten Teams unterstützt wird. Bei der Gestaltung des Systems sind noch wesentliche Entwurfsentscheidungen im Detail zu klären. In zwei Bachelorarbeiten, die in enger Kooperation durchgeführt werden können, sollen zwei wesentliche Aspekte des Systems untersucht werden: Inkrementellen Updates von Benutzersichten und Datensynchronisation in einer verteilten Systemumgebung.
    Die Arbeit wird im Rahmen eines Institutsprojektes durchgeführt und wird von CELUM GmbH finanziell unterstützt.

  • Debugging Actor Programs with Visual Studio Code (VS Code, Graal & Truffle)
    While the actor programming model is increasingly popular with languages such as Scala and Erlang, its support for debugging in classic IDEs such as Eclipse, NetBeans, or Visual Studio Code is still rare. The goal of this project is to add debugging support for actor libraries and languages for instance for VS Code to help developers to understand the dynamic behavior of their code better.
    Contact: Dr. Marr

  • Automated Debugging: Learning Actor Protocols from Correct Executions (Graal & Truffle, Actor Concurrency, Testing, Debugging)
    Debugging concurrent programs is hard. While problems in sequential code often manifest as errors deterministically, in concurrent systems, we have the additional challenge of non-deterministic schedules and race conditions. To facilitate debugging and correctness of concurrent programs based on the actor model, we can use so-called contracts, state-machine-like definitions of how actors are expected to communicate. However, constructing such contracts for complex systems can be a lot of effort. In this project, we want to explore generating them based on observed executions that lead to correct results.
    Contact: Dr. Marr

  • Implementation of a Register Allocation Verifier for the Graal Compiler
    Graal is a new just-in-time compiler for Java that is itself written in Java. It is based on a port of the HotSpot client compiler from C++ to Java. Due to its modular design it is easy to add new register allocators but creating a new allocator, or improving an existing one, is a tedious and error prone task. The goal of this project is to implement a register allocation verification framework based on static analysis.
    Contact: DI Josef Eisl

  • Automatisches Software-Testen im .NET-Umfeld (Fa. Doka)
    Die Firma Doka aus Amstetten hat in den letzten Jahren ein Softwaresystem mit den Microsoft-Technologien C#, .NET 4.5, VisualStudio 2013, WPF, WCF und MVVM aufgebaut. Dadurch ist es möglich, alle Systemkomponenten und sogar die Programmoberflächensteuerung durch Verwendung von MVVM vollautomatisch zu testen. Erste Unit-Tests sind bereits implementiert. Im Rahmen dieser Arbeit sollen weitere Tests für die Oberfläche sowie für den Workflow geschrieben werden.

  • Safe Data Structures for C
    C does not have automatic memory management, every memory access is "unsafe", and there is also no type checking. This project aims to introduce memory and type safe data structures for a Truffle-based C interpreter (similar to what Java provides). The goal of this project is: investigate feasibility of safe data structures for C wrt. implementation effort; determine restrictions of safe data structures compared to regular raw-memory allocations in C; develop a prototype implementation of safe data structures for a given C interpreter.
    Contact: DI Grimmer

  • Multi-Language Console
    The Truffle platform allows programmers to execute programs that are written in multiple languages. This project aims to implement a multi-language command line tool for Truffle-based language implementations. The goal is to allow programmers to select the language for each statement and therefore write multi-language applications.
    Contact: DI Grimmer

  • CUDA/OpenCL integration via Truffle interoperability
    Truffle is a framework for implementing language runtimes on a Java VM. There are existing implementations for many languages on top of Truffle (JS, Ruby, R, etc.), and they can communicate with each other through Truffle's interoperability layer. The goal of this project is to create a Truffle language implementation for CUDA or OpenCL, so that other languages can transparently call code that is executed on the GPU. The implementation should handle the communication with the GPU and the data marshalling, so that it is as easy as possible to integrate GPU code into applications written in other Truffle languages.

  • Test language interoperability between JavaScript and Ruby (JavaScript, some Ruby and Java)
    The Truffle Framework allows you to write code that interoperates between different languages. In this project, you should prepare test cases to see how well-behaving JavaScript is when executing on foreign (here: Ruby) objects. What happens when you try to execute methods from JavaScript's core library on Ruby objects? The project should result in a complete set of unit tests and an analysis of the failing behaviour.
    Contact: Dr. Wirth

  • Use serial/waiting time to perform independent tasks during young gc in G1
    In the Oracle HotSpot Garbage First (G1) collector, young GC often contains periods of time where worker threads are waiting for others (termination time) or executes something serially. This time could be used to perform some tasks that have no dependencies on other tasks and otherwise consume a significant amount of time. Prominent examples for such tasks are a string table and symbol table cleanup that take a significant (i.e. most) amount of time during other pauses, but could be scheduled at any time during a stop-the-world pause.
    Contact: DI Schatzl

  • NUMA for G1
    There have been a few attempts at adding NUMA support (exploiting locality of memory in multi-socket systems) of varying complexity into older versions of the Garbage First (G1) collector. The goal is to look at existing proof of concept implementations, try to unify them and measure impact. A NUMA system can be easily emulated on Linux for development, for performance tests suitable machines are available.
    Contact: DI Schatzl