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

• Continuous Integration for Ant Tracks
  The goal of this work is to develop an application that delegates building and testing to other machines with different kinds of operating systems and architectures. It must collect the results and display to the user on which systems the build and the tests were completed successfully or on which they failed. If a build or test failed, the user introducing the breaking changeset must be notified via email. Which users are to blame must be narrowed down by looking at the last commit authors or the line a compile error occurred. A more detailed description can be found here.
  Supervisor: DI Lengauer
  Student: David Kowanda


• Framework for incremental optimization
  In a workshop, students shall experiment with strategies for incremental optimization of the travelling salesman problem (TSP). The goal of this project is to develop a Java framework that provides the infrastructure, so the students can concentrate on the actual algorithms. The framework shall read input data (coordinates of "cities"), provide basic data structures and operations for routes, compute costs, display routes graphically, etc. Usability and learnability are important; the workshop participants should be able to familiarize themselves with the system quickly, so they can immediately start developing their own algorithms.
  Supervisor: Prof. Blaschek
  Students: Michaela Schönbauer, Melanie Donabauer


• An implementation of 64-bit integer arithmetic for JavaScript
  JavaScript's only numeric datatype is a 64-bit floating point double, which means that it cannot directly express operations on 64-bit integers similar to Java semantics. The prototype JavaScript-based backend for the Graal compiler will need an efficient implementation of long arithmetic. The goal of this project is to design a representation of 64-bit integers in JavaScript that fits well into the architecture of the backend and implement all operations on long available either as Java bytecode or via the java.lang.Double class.
  Supervisor: Dr. Stadler
  Students: David Leopoldseder


• Improved collection failure handling in G1
  Collection failure, when there is not enough space to evacuate objects from the young generation to somewhere else, is a rare occurrence. For this reason, the mechanism to recover from these failures is extremely unoptimized, taking seconds on larger heaps. The existing handling should either be parallelized, or a better algorithm devised.
  Supervisor: DI Schatzl
  Students: Walter Gugenberger


• Implementation of an alternative register allocator for 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. There are several well known algorithms that are slower but can potentially emit better code. The aim of this project is to implement one of those approaches, find out how big the gap really is and why it even exists.
  Supervisor: DI Eisl
  Students: Florian Schröckeneder


• Reengineering of the SSW blackboard system
  At the SSW, there is a large screen that shows a directory of the institute's staff, with photos, location information, assignment to work groups, announcements, and more. The system consists of a web-based display component and a backstage part for administration of the displayed information. The goal of the project is to redesign and reimplement the system, in order to resolve known problems with the existing solution.
  Supervisor: Prof. Blaschek, DI Lengauer
  Students: Elozino Ofualagba, Anamaria-Iulia Pascu


• Partial Safepoints for Profiling
  Sampling profilers periodically pause application threads to collect their stack traces, which are then merged into the profile. The popular HotSpot Java VM uses "safepoints" to pause threads, which affect all threads, delay stack walks until each thread is paused, and keep all threads paused until all stack traces are collected. The goal of this project is to implement partial safepoints for profiling, which only affect a subset of threads, walk a thread's stack as soon as it is paused, and pause threads no longer than necessary.
  Supervisor: DI Hofer
  Student: David Gnedt


• Visualization of Lock Contention Event Traces
  Multithreaded applications use locks to protect shared resources, but frequent lock contention can diminish the speedup from parallelization. We are researching a Java virtual machine which records lock contention in a detailed event trace with very low performance impact. The goal of this project is a tool that enables a user to analyze such traces in a versatile way by breaking down the total contention by multiple freely selectable aspects (such as threads or methods) and visualizing this drill-down in a tree structure.
  Supervisor: DI Hofer
  Student: Andreas Schörgenhumer

More Topics

Please see here

Final Presentation

Mo 22.6.2015, 13:45 - 15:15, room S3 218

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.