Project in Software Engineering

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 (presentation on Mo. 24.06.2024, 15:30-17:00)

• 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.
  Contact: DI Thomas Schatzl
  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.
  Contact: DI Thomas Schatzl
  Student: Naçar Alpay
  
  
• Implementation of several Python Core Modules in GraalPy (Technologies: Java, Python)
  ...
  Contact: Dr. Florian Angerer
  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)
  ...
  Contact: Dr. Markus Weninger
  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.
  Contact: Dr. Markus Weninger
  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.
  Contact: Dr. Markus Weninger
  Student: Tobias Herber
  
  

Already started before SS24 (presentation on Mo. 06.05.2024, 15:30-17:00)

• Basic GDB Debugging Support for GraalVM
  Contact: Hanspeter Mössenböck (Technical supervisor: Paul Wögerer (Oracle Labs))
  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

Started WS24/25 (presentation in March 2025)

• QoL Features for a Semester Planner Web Application (WebDev)
  In a Bachelor's thesis, a web application was developed that allows JKU students to plan the weekly schedule of the courses they want to attend in the next semester. This tool should be extended by further functionality such as advanced searching and filtering, printing as well as an export of the schedule for backup purposes. Most importantly, an authentication via single sign-on should be added and possibilities should be explored how this tool can be integrated into myJKU.
  Contact: Prof. Hanspeter Mössenböck
  Student: Alexander Burghuber
  
  
• Constrained Grammar-Based Generation and Mutation of Code (Java, ANTLR)
  Code generation and mutation is an essential part of randomized compiler testing (compiler fuzzing). Using attributed grammars to generate and mutate code provides support for various languages. The task is to create a grammar-based code generator that adheres to certain constraints, such as the liveness of all generated assignment statements. Using a standard grammar definition, e.g. ANTLR, it should generate code in both Java and other languages.
  Contact: Prof. Hanspeter Mössenböck (Technical supervisor: Gergö Barany (Oracle Labs))
  Student: Florian Schwarcz
  
  
• Interactive and Playful Visualizations of Graph Flow Algorithms (WebDev)
  In the course "Algorithmen und Datenstrukturen 2" (Algorithms and Data Structures 2) at the Johannes Kepler University, students learn about graph flow algorithms. Currently, the teaching materials for these topics are limited to slides and blackboard explanations. To enhance the learning experience for students and provide lecturers with more effective teaching aids, an interactive and playful visualization tool for graph flow algorithms can be developed. The goal of this project is to create an interactive visualization tool that supports lecturers in teaching and helps students learn graph flow algorithms more effectively. The tool should include the following features:
  1. Graph building and editing:
  - Allow users to add, remove, and edit nodes and edges in a graph.
  - Enable users to change node names and edge weights to create custom graph structures.
  - Provide functionality to lay out graphs automatically for better visualization.
  2. Visualization of the Edmond-Karps graph flow algorithm:
  - Implement visualizations for said algorithm.
  - Visualize the algorithm step-by-step, highlighting the nodes and edges/flows being traversed or updated.
  3. Modes for teaching and learning:
  - Step-by-step mode: Allow lecturers to present the algorithm's process step by step, with the ability to move forward and backward through the steps.
  - Play mode: Engage students by asking them questions about the algorithm's next steps. For example, ask which path will be chosen next and how the graph's flow will change by taking that decision.
  - Provide immediate feedback on the correctness of student answers and offer explanations for incorrect responses.
  4. Web application:
  - Implement the interactive visualization tool as a web application using modern web technologies such as HTML, CSS, and JavaScript.
  - Design an intuitive and user-friendly interface that is easy to understand, navigate, and use.
  - Ensure compatibility with modern web browsers and responsiveness across different devices.
  The interactive visualization tool should be developed with a focus on usability and educational value. It should provide a visually appealing and engaging experience for both lecturers and students, making it easier to teach and learn graph and graph flow algorithms.
  Contact: Dr. Markus Weninger
  Student: Sebastian Stiegler
  
  

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.