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 persons. At the end of the semester, the results should be presented in a 15 minutes presentation.

Topics

• 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' UI. This is currently done in a default Java Swing 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.
  Contact: Dipl.-Ing. Philipp Lengauer, Markus Weninger
  Student: Christine Atzmueller


• JavaFX for AntTracks (Java, JavaFX)
  AntTracks is an offline memory monitoring tool for Java that is currently implemented in Swing. The goal of this work is to incrementally port the UI in a top-down manner from Swing to JavaFX and refactor it based on an Model-View-ViewModel approach. Components with custom rendering can still be embedded as Swing components.
  Contact: Dipl.-Ing. Philipp Lengauer, Markus Weninger
  Student: Daniel Pucher


• An Online Tool for Handling Student Exchanges at IAESTE Austria
  The goal is to develop a tool (from the front end to the database) that supports IAESTE Austria in handling their student exchange program. The project consists of 2 parts: (1) Handle registrations of outgoing students; upload project descriptions for which the students can apply. (2) Handle the projects of incoming students. A complete specification of both parts is available. A certain financial support is possible.
  Supervisor: Prof. Mössenböck, Mark Feichtinger (IAESTE)
  Student: Christopher Warmbold


• Implementation of Interference Region Spilling for a Graph-Coloring Register Allocator in Graal
  Graal is a just-in-time (JIT) compiler for Java bytecode that is itself written in Java. Like many other JIT compilers Graal uses the linear scan algorithm for allocating registers, which is fast but does not produce the best quality code. In course of a Master's Thesis a graph-coloring register allocator was added to Graal. The goal of this project is to replace the simple spilling mechanism of the initial implementation with a region spilling approach that reduces number of required spills and loads.
  Supervisor: DI Eisl
  Students: Florian Schröckeneder


• Node.js benchmark suite (JavaScript, Node.js)
  Node.js is a JavaScript-based runtime environment (mostly) for server-sided web applications. To track the performance of engines executing Node.js applications and compare them, a set of Node.js specific benchmarks should be written. While existing JavaScript benchmark suites test the performance of the core runtime, this set should facilitate the characteristics of typical Node.js applications, such as parallel request handling, IO performance, VM-level performance (e.g. garbage collection).
  Contact: Dr. Wirth, Dr. Bonetta
  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. Wirth, Dr. Bonetta
  Student: ?


• Safely Combining Shared Memory Concurrency with Message Passing (Graal & Truffle)
  With the wide availability of multicore systems, concurrent programming becomes increasingly necessary to achieve the desired performance for a wide range of applications. The actor programming model provides a safe model for such programs, avoiding many of the pitfalls of shared-memory concurrency based on threads. In the past, we explored ideas to bring the safety of the actor model to shared-memory programming as well. The goal of this project is to apply these ideas to a new programming language called SOMns.
  Supervisor: Dr. Marr
  Student: ?


• 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.
  Supervisor: Dr. Marr
  Student: ?


• 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.
  Supervisor: Dr. Marr
  Student: ?


• Improve G1 concurrent marking
  The G1 garbage collector in the Java HotSpot VM uses concurrent marking to determine which objects are live and which not. It is serviceable, but its memory usage is very conservative: it statically sizes a few very large in-memory structures so that it will never need to reallocate. This wastes a lot of memory and time to initialize them in many applications.
  The goal of this project is to improve average memory usage of the concurrent marking by lazily allocating und using these data structures.
  Supervisor: DI Schatzl
  Student: ?


• Implementation of a Register Allocation Verifier for the Graal Compiler (Graal, Java)
  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 Eisl
  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.

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.