logo of the SSW institute ;)
Computer Science
System Software




PhD Theses
Go Abroad



Project in Software Engineering

339.018 Mössenböck + members of SSW/CDL MEVSS/Oracle Introduction: Mo 5.3.2018, 16:00, S3 218 Presentations: Mo 2.7.2018, 10: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 persons. At the end of the semester, the results should be presented in a 15 minutes presentation.


  • Time Series-based Event Prediction in Heterogeneous Large-Scale Systems
    Dynatrace provides rich monitoring data of their customers’ systems including detailed time series data and event data. The time series data is available in 1-minute resolution and covers various metrics such as CPU utilization, disk latency, number of worker threads, etc. The event data comprises several types of problems and events such as process crashes, increased error rate events, service slowdown events, etc.
    The goal of this project is to develop a supervised machine learning predictor which takes as input time series data and predicts the likelihood and time of a specific event (time-to-event prediction). This includes appropriate data processing, data selection and parameter tuning.
    Student: ?

  • Tool Development for Integration of Existing Crash Analysis Approach
    We developed a crash analysis approach for our industry partner Dynatrace which automatically extracts interesting cases of crashed software frameworks based on multi-system monitoring data. The goal of this project is to develop a tool which allows users to continuously apply this crash analysis approach (periodically on new monitoring data), create crash-analysis reports and visualize specific crash properties (e.g., occurrences of exception messages) over time to detect possible trends.
    Student: ?

  • Visualizing Infrastructure Architecture Graphs Including Time Series Metadata
    Dynatrace provides rich monitoring data of their customer’s systems, including system components and their connections, detailed time series data and event data. The goal of this project is to develop an visualization of such a system as an interactive graph, which should include visualizing nodes, edges and time series for a given node, setting a filter on the time interval to be observed, setting a filter on the time series metrics to be observed and visualizing events in the time series graphs.
    Student: ?

  • Graph Visualization in AntTracks (Java, JavaFX)
    AntTracks is an offline memory monitoring tool that collects various information about heap objects during an application's execution, such as an object's type or allocation site, alongside references between these objects. This allows reconstructing the heap object graph for a given point in time, yet AntTracks currently lacks a convenient way to visualize graphs.
    The goal of this project is to develop a graph visualization system for JavaFX that allows the rendering of arbitrary graphs, e.g., heap object graphs. Functionality should include (but is not limited to): Visualizing nodes (variable shapes, icons, expandable information, variable colors), visualizing edges between nodes (edge labeling, variable thickness, variable styles), lazy loading of child nodes on first parent node expansion, automatic layout of nodes (e.g., hierarchical).
    Supervisor: DI Markus Weninger
    Student: ?

  • Basic Java Source Code Editor for AntTracks (Java)
    AntTracks is an offline memory monitoring tool that allows users to analyze heap memory by classifying heap objects based on various properties. Beside pre-defined classifiers, the user is able to define custom classifiers at run-time within AntTracks's UI. This is currently done in a default JavaFX text component, without sophisticated text highlighting support and no code completion. The goal of this project is to develop a text control that supports basic IDE functionality like Java Syntax highlighting and simple code completion with the help of a pre-existing Java Compiler.
    Supervisor: DI Markus Weninger
    Student: ?

  • Exposing the Reliance of Binary Programs on x86 Implementation-Dependent Behavior
    Some processors produce implementation-dependent or undefined values for certain inputs. For example, on x86, the bsr instruction (which scans an input value for the least significant set bit) produces an undefined output value if 0 is given as input. While undefined output values are usually predictable for a certain architecture, future architectures might behave differently. The goal of this project is to investigate whether undefined behavior in x86 instructions affects the observable program behavior (i.e., the output of a program printed to the console). To this end, an emulator (such as QEMU) or a dynamic binary instrumentation framework (such as DynamoRIO) should be modified to generate a random output value for an operation that is given undefined input.
    Supervisor: DI Manuel Rigger
    Student: ?

  • 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.
    Supervisor: DI Manuel Rigger
    Student: ?

  • 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.
    Supervisor: DI Manuel Rigger
    Student: ?

  • Parameter space exploration to optimize compiler settings (Python and/or additional languages)
    VMs such as V8 and the JVM can be fine-tuned to optimize for specific workloads. The GraalVM multi-language virtual machine is no exception, and fine-tuning heuristic-based runtime components such as inlining and splitting can greatly affect the VM performance. Moreover, the VM is multi-language, and the best configuration for a language is not necessarily acceptable for another language. In this project, you will develop a software tool to perform automatic exploration of the configuration parameters of the GraalVM, to identify how each parameter affects the performance of the engine in a cross-language setup. The goal is to identify one or more VM configurations that are suitable for cross-language workloads via automatic performance testing. The software artifact will be integrated in Oracle Labs' CI infrastructure.
    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: ?

  • Code Formatting for SOMns
    SOMns is a Newspeak based language for concurrency research. The goal of this project is to develop a code formatting tool for SOMns using SOMns. The Parsing infrastructure of Newspeak should be ported to SOMns as a basis for the tool. The formatting is then implemented using the Abstract Syntax Tree provided by the Parsing Infrastructure.
    Student: ?

  • Region pinning for G1
    The G1 garbage collector in the HotSpot VM is a region based incremental garbage collector that can evacuate (move) around objects at will. While this allows you to fight fragmentation, moving around objects does not help with interfacing with non-garbage collected code like C. For this reason, while some C code accesses Java memory, the VM prevents the garbage collector to perform its task. This does not work well in situations where memory is already tight. One alternative approach usable with G1 would be to, instead of preventing any garbage collection work, only prevent garbage collection work for heap areas which contain Java objects that are currently in use with native code.

    Goals of this work are a working implementation of region pinning in the G1 collector. Consider implementing techniques to mitigate wasting complete regions for a few pinned objects by allowing simple allocation into them. Evaluate the change and compare it to the existing mechanism of providing non-moving memory.

    Supervisor: DI Thomas Schatzl
    Student: ?

  • Visualization of Garbage Collection Techniques
    In the course on "System Software", there is a chapter on Garbage Collection, which covers basic algorithms as well as advanced techniques for automatically reclaiming unused memory space. To make these topics easier to understand, it would be great to have animated visualizations that illustrate how the garbage collection algorithms work.
    The goal of this project is the development of an interactive application that simulates creation of objects and the cleanup process with different garbage collectors. The results should be displayed in an animated graphical representation that shows how obsolete objects are detected and finally removed. Which garbage collection algorithms are to be covered will be defined at the beginning of the project.
    Student: Martin Steinscherer, k0057247

  • Visualization of Tree Algorithms
    In courses about algorithms and data structures, tree algorithms play an important role, but advanced trees and algorithms for balancing and traversing trees are difficult to understand. In particular, these algorithms are typically recursive, and it is not easy to keep track of the various recursion levels.
    The goal of this project is the development of an interactive application that illustrates and animates various types of trees and algorithms for building, searching, traversing and balancing such trees. Which types of trees and which tree algorithms are to be covered will be defined at the beginning of the project.
    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. 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.