Project in Software Engineering

339.018 Mössenböck + members of SSW/Oracle Labs Introduction: Mo 02.03.2020, 15:00, S3 218 Presentations: Mo 29.06.2020, 14:00, S3 218


The goal of this course is to do a non-trivial software project over a whole semester and to go through all its phases (requirements definition, design, implementation, testing, documentation). The projects should be done in teams of 2, but can also be selected by a single student. At the end of the semester, the results should be presented in a 15 minutes presentation.

Available Topics

  • Fuzz Testing Framework for the GraalVM LLVM Runtime (C/C++, Java, Python, LLVM IR, ...)
    Fuzzing is an automated software testing technique where a Fuzzer automatically generates inputs for a computer program in order to find unexpected behavior. Fuzzing a language implementation is especially interesting since the input is not just data but a program. The challenge is to tell apart interesting failures, i.e., due to an incorrect implementation, from less interesting ones, e.g., syntax errors, non-determinism or unexpected behavior in the generated program. The goal of this project is to create a fuzz testing infrastructure for the GraalVM LLVM Runtime (aka Sulong). The GraalVM LLVM Runtime is a language implementation that executes LLVM IR, an intermediate representation used for example by the Clang C/C++ compiler. The emphasis of the project is not on finding as many issues as possible but to present issues in a way that is useful to the language implementers, e.g., minimal reproducer, detection of duplicates, etc.
    Student: Arif Celik

  • COCO/R Parser for IEC 61631-3 Structure Text (Java)
    IEC 61631-3 is a standard for languages for Programmable Logic Controller (PLC) Programs. One language within this standard is Structure Text, which is a language similar to Pascal. In this project a Coco/R parser for building an abstract syntax tree should be created.
    Student: ?

  • Data Flow and Call Graph Analysis for IEC 61631-3 Structure Text Programs (Java, optional Kotlin)
    IEC 61631-3 is a standard for languages for Programmable Logic Controller (PLC) Programs. One language within this standard is Structure Text, which is a language similar to Pascal. In this project, data flow and call graph graphs should be created for Structured Text programs. Data flow graphs represent the data dependencies between program statements. A call graph represents the call dependencies between procedures. The input is an abstract syntax tree of Structured Text programs (see project above). Remark: It is also possible to split the task into two independent projects, one for the data flow and one for the call graph.
    Student: ?

  • Creating Truffle ASTs from a Simple Programming Language (Java)
    PELang is a simple programming language that has been developed for testing and benchmarking programs in Oracle's Truffle framework. So far, PELang programs have been implemented by writing Java code that programmatically created Truffle ASTs that were then further processed. Since creating ASTs manually is a tedious task, the goal of this project is to define a grammar for PELang and to write a small "compiler" that creates the Truffle ASTs automatically from PELang programs. For writing the compiler, a parser generator such as Coco/R or ANTLR should be used.
    Student: ?

  • Evaluation of Machine Learning Models for Compiler Optimizations (Java)
    For a mere user, machine learning is often considered as a black box. From a pool of existing ML techniques - ranging from simple linear regression to more complex neural networks - often similar, yet slightly different results can be achieved for a given prediction task. For this project a sample machine learning task in the context of compiler optimizations shall be used to evaluate different ML models and parameter configurations. The goal is to find (near) optimal settings (model + parameters) for the given and similar prediction tasks, according to prediction accuracy and run time performance.
    Student: ?

  • Data Structure Detection in the Memory Analysis Tool AntTracks (Kotlin (very similar to Java))
    AntTracks is a memory monitoring tool written in Kotlin and Java with a JavaFX UI frontend that is used to detect and analyze memory anomlies such as memory leaks. Often, memory leaks are related to data structure misuse, e.g., programming errors leading to growing data structures (such as lists, maps, sets, etc.). The goal of this project is to automatically identify data structures in the heap, for example, to automatically identify that LinkedList objects are data structures that internally consist of LinkedList$Node objects that point to data objects. The student should experiment with different approaches (from literature and/or own ideas) and should regularly discuss their applicability with the supervisor.
    Student: ?

  • New JavaScript Language features - ECMAScript proposals (Java, some JavaScript)
    JavaScript is specified in the ECMAScript language specification. It is an evolving language, and is improved by a "proposal" process. Each new or improved feature is specified by one proposal. Currently open proposals include Temporal (a date/time library), optional chaining (avoiding null value exceptions), decorators (similar to Annotations in Java), additional methods to the Set builtin, and many more. As the different proposals vastly differ in effort to implement them, we have topics for projects (project in software engineering), bachelor theses and master theses. The task is to fully implement the current state of the proposal in the GraalVM/Graal.js JavaScript engine.
    Student: ?

  • Visualization of Execution Traces (Javascript, d3.js)
    The goal of this Project is to develop a new visualization of execution traces for the browser-based Kompos debugger. Debugged programs send information about the execution to the debugger, which enable it to provide unique breakpoints, stepping operations and visualization. However, the existing visualization of message dependencies does not provide useful information. The visualization of messages should be reimplemented to aid users in better understanding their programs.
    Student: ?

  • Documentation System for SOMns
    SOMns is a Newspeak based language for concurrency research and its runtime modules are currently not documented. The goal of this project is to develop a comment-based (like in JavaDoc) documentation system for SOMns, and integrate it into the SOMns plugin for VS Code.
    Student: ?

More Topics

Please see here

Final Presentation

The results of every project have to be presented by all team members in a 15 minutes presentation on Monday, June 29, 14:00-16:00 in room S3 218. The presentation should mainly consist of a demo, but you should also shortly explain the problems tackled in this project and how you solved them.


The mark is derived from the quality of the implemented software (functionality, user friendlyness, robustness, readability and maintainability, documentation) as well as from the final presentation and the commitment during the semester.