logo of the SSW institute ;)
Computer Science
System Software

Home

General
Staff
Contact
Partners
Alumni

Research
Areas
Projects
Papers
Books
Reports
Awards

Teaching
Lectures
Exams
B.Projects
M.Theses
PhD Theses
Go Abroad

Misc
Talks
Library
Gallery
Links
Search

Webmaster


Project in Software Engineering

339.018 Mössenböck, 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

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.
    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.