Project in Software Engineering

Goal

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.

Assigned Topics

• A Web-based Tool for doing Quizzes in Courses (Java, JavaScript)
  The goal of this project is to develop a web-based tool where a lecturer can ask questions and students can provide answers interactively via a notebook or a mobile. The answers should be immediately evaluated and visualized (individually or in summary). Question types should be multiple choice and free text (maybe also source code). For developing the tool, simplicity and responsiveness are more important than the number of features.
  Contact: Prof. Mössenböck
  Student: Marindo Beka, BSc.


• Visualizing Memory Evolution as Software Cities (Java, C# (Unity))
  AntTracks is a memory monitoring tool that uses memory traces (i.e., recordings of memory events) to reconstruct an application's memory evolution. The live heap objects can be reconstructed, classified and grouped at every garbage collection point. For example, it is possible to first group all objects by their types, and then each of these groups by their allocation sites, which results in hierarchical classification trees. Currently, the evolution over time of object groups in these trees is only visualized using time-series charts.
  The goal of this project is to explore new visualization techniques that enable the investigation of the application's memory evolution over time. Specifically, the software city metaphor should be used to visualize the memory evolution as growing and evolving cities. Buildings in these cities represent object groups (such as types or allocation sites) extracted from the classification trees.
  Contact: DI Markus Weninger
  Student: Lukas Makor, BSc.


• Graphical Tool to switch running Java applications to AntTracks (Java (UI), C (Native Agent / JVMTI))
  AntTracks is a memory monitoring tool that records memory traces, i.e., information about memory events such as allocation or moves executed by the garbage collector. To do so, AntTracks relies on a custom Java Virtual Machine (JVM) for event recording. Thus, no memory traces can be recorded for applications that are not running on such an AntTracks VM.
  The goal of this project is to ease the workflow of starting applications on the AntTracks VM. Currently, to instruct a Java application to use the AntTracks VM, global environment variables such as JAVA_PATH have to be changed, often in combination with tedious adjustments to application start-up scripts. As part of this project, a tool with a graphical user interface should be developed that lists all running Java applications, independent of the used VM. If the user decides to trace one of these applications, the tool should extract its command line parameters (e.g., by reading its RuntimeMXBean), shut it down, and restart it with the same parameters, this time on an AntTracks VM with enabled tracing.
  Contact: DI Markus Weninger
  Student: Markus Mülleder, BSc.


• Automatic Debugging Assistant for Actor Programs (Java)
  Debugging of Concurrent Programs can be difficult due to their non-determinism, as bugs may occur only under rare circumstances. The problem of non-determinism can be solved by employing record & replay to capture those circumstances, and allow for deterministic reproduction of a program execution. What remains is the challenge to debug a complex program, finding the right places to set breakpoints and choosing the right stepping operations requires try and error. The goal of this project is to develop debugging features for SOMns (a Truffle language, implemented in Java) that guide the debugging efforts towards the bug. When the program crashes, we have an execution trace that allows us to reproduce the execution, and a stack trace of that error. Using both traces we can analyse when and where a breakpoint is useful, and allow developers to focus on inspecting the program to find the cause of the bug.
  Contact: DI Dominik Aumayr
  Student: Patrick Fritsch, BSc.


• Two Factor Authentication for Swiftlox (Kotlin/RxJava)
  This project is conducted in cooperation with Swiftlox GmbH, Linz.
  Swiftlox provides a system for smooth and secure check-out processes in Web shops. It is intended to replace passwords by smartphones, manage all relevant user data, and offer an easy to use push-message channel to the end customer. In this project, Swiftlox should be extended by a two-factor authentication process with fingerprint as the seconnd factor. The project will be developed in Kotlin and based on the RxJava reactive framework.
  Contact: Dr. Herbert Prähofer
  Student: Clemens Bartl

Available Topics

• Low-Overhead Debugging with Sulong (Java, C)
  Sulong is an interpreter for LLVM IR, an intermediate representation of source code that can be produced by the Clang compiler for the C family of programming languages. It is based on the Truffle framework for implementing interpreters for programming languages and part of the GraalVM project. In addition to executing programs that were compiled to LLVM IR, Sulong also supports GraalVM's integrated debugging framework to allow users to debug these programs at source-level. At the moment, this debugging support is aimed at providing correct values for all possible symbols. This, however, comes at the cost of a significant run-time overhead since it prevents or even requires undoing several performance optimizations introduced by both Clang and GraalVM.
  The goal of this project is to implement an alternative performance mode for source-level debugging with Sulong. Instead of providing current values for all source-level symbols, in this mode the debugger should display only symbols whose values are still available despite optimizations. This will require analyzing the LLVM IR executed by Sulong and the debug information it contains. Once GraalVM's debugging framework has halted the running program and requests symbol information from it, the values referenced in the debug information can be compared against the current program state to determine which values are still available. For this project, no knowledge about compiler optimizations performed by either Clang or GraalVM is required.
  Contact: DI Jacob Kreindl

  Student: ?


• Time Series-based Event Prediction in Heterogeneous Large-Scale Systems
  One of our industry partners 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.
  Contact: DI Andreas Schörgenhumer
  Student: ?


• Visualizing Infrastructure Architecture Graphs Including Time Series Metadata
  One of our industry partners 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.
  Contact: DI Andreas Schörgenhumer
  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.
  Contact: Dr. Christian Wirth
  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.

  Contact: DI Dominik Aumayr

  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.
  Contact: DI Thomas Schatzl
  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, July 1, 10:00-12: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.

Marking

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.