Project in Software Engineering

339.018 Weninger + members of SSW/Oracle Labs Introduction:
Mo 04.03.2024, 16:00, SP3 218
Presentations:
Mo. 06.05.2024, 15:30-17:00 (no Master's Thesis Seminar on this day), SP3 218
Mo. 24.06.2024, 15:30-17:00 (no Master's Thesis Seminar on this day), SP3 218

The kickoff meeting as well as the final presentation meeting are both happing in person in room SP3 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 can be done in teams of 2 (with doubled workload), but can also be selected by a single student. At the end of the semester, the results have to be presented in a 15 minutes presentation.

Topics

Open Topics

The following list contains open thesis topics that might have to be adjusted in size to fit as topic for Project in Software Engineering. You might also find an interesting open master thesis topic that could be adjusted to a Project in Software Engineering.
If you are interested in working on one of these topics, please contact the respective supervisor and discuss the scope of the work.
Once you have done this, please inform Dr. Markus Weninger (markus.weninger@jku.at) to mark your topic as assigned.
If you did not choose a topic before the introduction meeting (which has mandatory participation for everybody), you have to select one of the remaining open topics during that meeting.

Assigned Topics

  • Aborted: Fixed Memory Marking for G1 (Technologies: C++)
    Summary: Implement a marking algorithm that uses (small) constant memory and compare with the existing. The G1 garbage collector is the current default garbage collector in the OpenJDK Hotspot VM. Its algorithm to determine reachable objects is a straightforward implementation of the Tri-Color abstraction. The drawback of this algorithm is that mark stack, a helper data structure, memory requirements is only bounded by the number of live objects which can be a very large number (in the MBs). There is an algorithm that bounds only needs a very small mark stack and a small helper table to complete marking. The task for this work comprises:
    • Implement the mentioned algorithm in the G1 garbage collector
    • The description only describes single-threaded operation, extend it to use multiple threads.
    • Compare its performance and memory consumption to the existing algorithm on benchmarks.
    Student: Pilz Tobias

  • Aborted: Automatic Dynamic Optimization of Remembered Sets (Technologies: C++)
    Let the G1 collector automatically determine remembered set container options for either reduced memory usage or improved performance. The G1 garbage collector is the current default garbage collector in the OpenJDK Hotspot VM. It uses remembered sets to store locations of incoming references to a particular region of the heap. This data structure is basically an implementation of a sparse set of integers: the entire range of possible values is split into evenly sized areas. A top level concurrent hash table stores values in areas that are "in" the set in a so-called remembered set container. Such a container is represented, depending on the number of values to be stored in that area it covers, by different kinds of data structures, e.g. arrays, bitmaps, or even single special integers. The remembered set implementation switches between containers on the fly depending on current remembered set entry occupancy of an area. G1 currently sizes these containers statically, i.e. independent of actual distribution of values in a given remembered set. So a particular container has a fixed size being able to hold a fixed amount of values, eg. an "array" remembered set container always has 128 entries, regardless of what the typical occupancy of such an array container is. This wastes memory, because different types of applications (and remembered sets for different areas of the heap) exhibit different occupancy characteristics. The task is to change G1 to let it reconfigure the remembered set containers based on statistics that need to be gathered while an application is running to optimize for the particular goal, and evaluate the effectiveness of these optimizations on several benchmarks.
    Student: Na├žar Alpay

  • Implementation of several Python Core Modules in GraalPy (Technologies: Java, Python)
    ...
    Student: Aliyev Yalchin

  • A Run-time Profiler for Java (Technologies: Nice language, cool framework)
    To optimize programs, it is helpful to know which methods consume the most run time. This project therefore aims to develop a profiler that instruments a Java source program in such a way that the time (in nanoseconds) at the start and end of each method is measured and the resulting run time per method is saved. The results are then to be visualized per class (aggregated run time of all its methods) and within a class per method.
    Contact: Prof. Hanspeter Mössenböck
    Student: Hofstadler Andreas

  • A Web-Based EBNF Railroad Diagram Visualizer (Technologies: HTML/CSS/Typescript)
    ...
    Student: Alexander Voglsperger

  • Visual Teaching in Compiler Construction through a Dynamic Operand Visualization (Technologies: Java (Agent), HTML/CSS/Typescript (Visualization))
    Currently, the compiler construction course at the JKU intensively uses unit tests to help students to find problems in their compilers. Nevertheless, having visual learning tools instead of just reacting textual error messages of failing unit tests would further help students to write correct code from the get-go. In this project, Daniel is provided with a trace file the contains information about
    • all method calls (i.e., which language productions the parser enters, for example Expression, Term, or Factor),
    • scans (i.e., information about tokens read by the parser),
    • as well as operand changes (e.g., switching an operand's kind from local to stack once it has been loaded)
    in a program run. His task is to provide a web-based visualization that provides the students with a easy-to-understand visualization that makes operand handling more tangible for students. The visualizations should allow the students to step back and forth through the recorded data, i.e., one should be able to explore how the input is read token by token in the various productions and how this creates new operands and changes existing ones. The goal is to use these visualization live during lectures, as well as to provide them to students for learning at home.
    Student: Daniel Jaburek

  • Visual Teaching in Compiler Construction through Dynamic Visualizations of Scanner Tokenization and Parse Trees (Technologies: Java (Agent), HTML/CSS/Typescript (Visualization))
    Currently, the compiler construction course at the JKU intensively uses unit tests to help students to find problems in their compilers. Nevertheless, having visual feedback instead of just textual error messages would further help students to more easily find a problem's root cause in their implementation. This project's aim is to a.) write a tool/agent to inject code at the correct locations in a student's implementation to record all necessary data and to b.) provide helpful visualizations based on this data. As a first step, two visualizations should be implemented: a.) A visualization of the scanner's tokenization process (i.e., a graphical representation of all tokens returned by Scanner.next() and b.) a visualization of the (top-down) parser's parsing process by showing the parse tree (i.e., a tree-based visualization of the scan(), error() and recursive descent methods called). The visualizations should allow the students to step back and forth through the recorded data, i.e., one should be able to explore the building of the parse tree step by step. The goal is to use these visualization live during lectures, as well as to provide them to students for learning at home.
    Student: Tobias Herber


Already started before SS24

  • Basic GDB Debugging Support for GraalVM
    Contact: Christian Wirth
    Student: Dominik Mascherbauer
  • Sparse conditional constant propagation for Graal IR
    Contact: Hanspeter Mössenböck (Technical supervisor: Gergö Barany (Oracle Labs))
    Student: Christoph Aigner
  • Moodle Feedback Visualization
    The students of the software development 1 course at JKU are actively encouraged to give weekly feedback about the lecture and its assignments via Moodle. However, Moodles capabilities regarding analysis of the feedback is limited. Analyzing all Feedbacks individually is a tedious tasks for lectureres. For example, grouping and filtering answers based on the selection in a multiple choice question, e.g., calculating the average required hours for all people that selected that the assignment was "very easy" needs to be done manually. Additionally, identifying trends across assignments is hard using only Moodle. Therefore the goal is to reduce the effort and mental load for lecturers by implementing a tool that visualizes correlations between the answers to questions of a single assignment and allows a visual overview of all assignments at once.
    Contact: Lukas Makor
    Student: Adrian Vinojcic

Final Presentation

The results of every project have to be presented by all team members in a 15 minutes presentation at the end of the semester. 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 (no bullet point presentation - rather use graphics and examples to demonstrate your problem and solution).

Grading

The grading is performed based on 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.