Project in Software Engineering
Bitto + members of SSW/CDL MEVSS/Oracle
||Introduction: Mo 2.3.2015, 16:00, S3 218
||Final presentation: Mo 22.6.2015, 13:45, 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.
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
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.
Students: Michaela Schönbauer, Melanie Donabauer
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.
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.
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.
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.
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.
Student: Andreas Schörgenhumer
Please see here
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.
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.