Skip to content

GSoC Ideas 2018

Jump to bottom
naraesk edited this page Feb 2, 2018 · 39 revisions

Application Instructions

Most likely you haven't used Getaviz yet. It is a tool mainly for researchers but also for developers to make software development easier and more fun. Therefore, please make sure to inform yourself about software visualization in general and about Getaviz before applying. Here are some good websites to start with:

If you still have questions, feel free to ask! Just write at softvis(at)uni-leipzig.de or open an issue. Anyway, please make sure to talk to your potential mentor before applying!

We don't provide a special template for your application. But please make sure to answer the following questions:

  • Who are you and what is your background? (University, studies, hobbies …)
  • What are your experiences? (programming languages/frameworks, jobs, part of an open source community …)
  • What are your expectations? Why have you chosen this project? (personal interests, specializations …)

About Google Summer of Code

This documents provides an overview over ideas for projects from Google Summer of Code 2018. Every idea consists of a list of keywords representing the technologies you are most likely will get in touch with during the project. This does not mean you already have to be familiar with them, preconditions are listed separately. Getaviz is a very heterogenous project, containing different components which uses completely different technologies. The keywords will help you to find a project you are interested in, so you can work with the technologies you are enthousiastic about! Further, the focus of most projects can be shifted a bit according to your interests. Just talk to us! The following list gives you an overview which technologies we use in Getaviz:

Programming languages

Web frameworks

Visualization frameworks

Hardware

Databases

Ideas

Generator

Support for JavaScript

  • Brief explenation Currently, Getaviz can visualize Java, Ruby, and C# code. To support JavaScript, an extractor have to produce FAMIX and DYNAMIX models of the program. These are textbased metamodels with a json-like syntax. From there on, the generation process will be language independent.

  • Expected results
    It is not the primary goal to develop an own JavaScript parser. It is much better to use existing tools and adapt them to produce FAMIX and DYNAMIX models

    • FAMIX-Model of JavaScript code can be created automatically
    • DYNAMIX-Model of a JavaScript program can be created automatically

  • Involved Technologies
    JavaScript

  • Knowledge Prerequisite
    You should already have some experience with JavaScript and should be interested in the language. With this task you can deepen your knowledge and get in touch with almost every aspect of the language, even the unpopular ones.

  • Mentor
    David Baum [david.baum(at)uni-leipzig.de]

Unity Output

  • Brief explanation
    Currently, 2D and 3D visualizations are generated in x3d and x3dom. Unfortunately they don't support HTC Vive. In contrast, unity supports this very well. To better support virtual and augmented reality, the generator should be capable of generating Unity as additional output format. We will try to provide you with a HTC Vice so you can test your implementation adequate. Further, it should be possibe to navigate within the VR model and interact with it. Finding suitable interaction and navigation concepts is a highly creative challenge where you can bring in your own ideas!

  • Expected results

    • Every currently supported visualization metaphor can be generated in Unity
    • Implementation of a basic interaction and navigation concept using HTC Vive controlers

  • Involved Technologies
    Java, Xtend, Xtext, Unity, HTC Vive, maybe C#

  • Knowledge Prerequisite
    This is a chellenging and explorative project! You should have experience with at least one high-level language, e.g. Java or C++. Experience with Unity is desirable. You will have to do a lot of testing/experimenting to find out, which navigation and interaction modes works best. Depending on your solution you might need C# or not.

  • Mentor
    David Baum [david.baum(at)uni-leipzig.de]

HoloLens Support

  • Brief explanation
    Currently, 2D and 3D visualizations are generated in x3d and x3dom. Unfortunately they don't support HoloLens. In contrast, unity supports this very well. To better support virtual and augmented reality, the generator should be capable of generating Unity as additional output format. We will try to provide you with a HoloLens so you can test your implementation adequate. Further, it should be possibe to navigate within the AR model and interact with it. Finding suitable interaction and navigation concepts is a highly creative challenge where you can bring in your own ideas!

  • Expected results

    • Every currently supported visualization metaphor can be generated in Unity
    • Implementation of a basic interaction and navigation concept

  • Involved Technologies
    Java, Xtend, Xtext, Unity, C#, Microsoft HoloLens

  • Knowledge Prerequisite
    This is a very chellenging and explorative project! You should have experience with at least one high-level language, e.g. Java or C#. Augmented Reality is new to us too. So its very important that you are creative and bring in your own ideas, but also that you are willing to dive into new technologies and try out different solution approaches.

  • Mentor
    David Baum [david.baum(at)uni-leipzig.de]

A-Frame Output

  • Brief explanation
    Currently, 2D and 3D visualizations are generated in x3d and x3dom. Unfortunately they don't support HTC Vive. In contrast, Mozillas A-Frame supports this very well. To better support virtual and augmented reality, the generator should be capable of generating Unity as additional output format. We will try to provide you with a HTC Vice so you can test your implementation adequate. Further, it should be possibe to navigate within the VR model and interact with it. Finding suitable interaction and navigation concepts is a highly creative challenge where you can bring in your own ideas!

  • Expected results

    • Every currently supported visualization metaphor can be generated in A-Frame
    • Implementation of a basic interaction and navigation concept using HTC Vive controlers

  • Involved Technologies
    Java, Xtend, Xtext, A-Frame, HTC Vive

  • Knowledge Prerequisite
    This project is suited for beginners. Experience with at least one high-level language, e.g. Java or C++. Experience with A-Frame is not necessary.

  • Mentor
    David Baum [david.baum(at)uni-leipzig.de]

Visualization metaphors

  • Brief explanation
    Currently, many software visualization metaphors are proposed in the scientific community. But most of them never get implemented or only in limited prototypes. We'd like to change that and implement as many existing visualizations in Getaviz as possible. Some suggestions:

  • Expected results

    • Reimplement one or more visualizations metaphors in x3d
    • Implement test cases
    • Visualization should be fully compitable with our user interface

  • Involved Technologies
    Java, Xtend, Xtext, x3d, x3dom

  • Knowledge Prerequisite
    Experience with at least one high-level language, e.g. Java or C++. Experience with x3d/x3dom is not necessary. Please be aware, that the difficulty highly depends on the selected visualization metaphors. For some visualizations it might be necessary to design visual components, such as an island or a building. For other visualizations it might be necessary to (re)implement layout algorithms. For other visualizations none of this is necessary. If you are unsure about the visualizations to select, please contact me. If you are mainly interested in designing visual objects but not into hard programming, we might find a solution too.

  • Mentor
    David Baum [david.baum(at)uni-leipzig.de]

Porting to neo4j

  • Brief explanation
    Currently, Getaviz uses model transformations and heavily depends on Xtext and mwe2 workflows. This solution is very inflexible and has many problems. We still want to use model transformations, but on top of a graph database such as neo4j. As described here, Getaviz consists of multiple components, whereby each performs a model transformation. The transformation must not be altered, but the models are loaded from and saved into the database

  • Expected results

    • no more mwe2 workflows
    • each component loads the model from neo4j
    • each component saves the model after the transformation to neo4j
    • the transformation itself does not change

  • Involved Technologies
    neo4j, Java, Xtend, Xtext

  • Knowledge Prerequisite
    This is advanced level! You should have experiences with graph databases and with at least one high-level language, e.g. Java or C++. The java/xtend coding should not be too complicated, but you will have to decide many things with implications for the future architecture. So you will have work close with the core team. Very important is the layout of the graph database, since this will have mayor influence on performance and usebility.

  • Mentor
    David Baum [david.baum(at)uni-leipzig.de]

User Interface

Multiple visualizations in the same UI

  • Brief explanation
    So far, only a single view of a model is visualized at the same time. However, for many purposes it is necessary to simultaneously analyse more than one view of the model or to analyse multiple views of different models, e.g. comparing two versions of the same system.

  • Expected results
    The main result of this idea is, that the UI can handle multiple views of the same model or different models. As a secund result it should be possible to couple this views, so an user event in one view has also affects the other view. For example the selection of an element in the first view selects also the element at the second view, if it exists and if it's displayed.

  • Involved Technologies
    JavaScript, x3dom

  • Knowledge Prerequisite
    Experience with JavaScript. Experience with x3d/x3dom is not necessary.

  • Mentor
    Pascal Kovacs [pkovacs(at)uni-leipzig.de]

Porting to d3

  • Brief explanation
    Currently, 2D and 3D visualizations are generated in x3d and x3dom. The user interface expects x3dom and cannot interact with other visualization framework. To better support user interaction and dynamic layouts, the generator should be capable of generating d3 as additional output format. It might be useful to use react components for this to increase reuse, but this needs further evaluation. Further, adaptors for the user interface have to be developed to be able to interact with d3 visualizations.

  • Expected results

    • Every currently supported visualization metaphor can be generated in d3 using react components
    • The user interface can interact with d3

  • Involved Technologies
    Java, Xtend, Xtext, JavaScript, d3, react

  • Knowledge Prerequisite
    The challenge in this project is the diversity of technologies you will get in touch wtih. You will have to write Java and JavaScript code. You should already be familiar with at least one of them, ideally with both. We don't expect you to know xtext or xtend. Experience with react and/or d3 is not necessary, but helpful. It is important that you are willing to learn and want to dive into new technologies.

  • Mentor
    Pascal Kovacs [pkovacs(at)uni-leipzig.de]

Dashboard

Software visualization components (d3)

  • Brief explanation
    The web-based software visualization dashboard supports software project managers in decision making. Its data source is an existing neo4j database with structural, behavioral, and evolutionary information of a software project. The dashboard consists of interactive react components where each component supports a certain task, e.g. hotspot, ownership, or test coverage analysis. Every component encapsulates a cypher query to fetch data from the existing neo4j database and d3 code for visualizing its results. This project can be assigned to several students where each student works on one component.

  • Expected results
    The software visualization dashboard is extended by a new component that supports a software project manager in decision making.

  • Involved Technologies
    JavaScript, react, d3, neo4j

  • Knowledge Prerequisite
    The challenge in this project is to find a suitable visualization that supports a software project manager and that can be build on the basis of the existing data in the neo4j database. You will have to write JavaScript and react code. You should already be familiar with JavaScript or react, ideally with both. Experience with d3 and/or neo4j cypher queries is not necessary, but helpful. You can either reuse existing d3 components or develop your own d3 visualization and you are supported with cypher queries by the mentor. It is important that you are willing to learning and want to dive into new technologies.

  • Mentor
    Richard Müller [rmueller(at)wifa.uni-leipzig.de]

Evaluation Server

Interaction Tracking

  • Brief explanation
    The evaluation server displays the evaluated scene in an iframe and provides an API to keep track of rudimentary interaction actions of the user with the scene. To improve the tracking of the interactions an advancement of the API and the Javascript responsible to interact with the API is desireable.

  • Expected results

    • Generalization of the API to facilitate the persistence of all browser interaction events like mouse movement, mouse click, and key press
    • Javascript-Script to track all the interactions and to send the informations to the API

  • Involved Technologies
    Ruby, Rails, Javascript

  • Knowledge Prerequisite
    Experience with at least one high-level language, e.g. Ruby or Java.

  • Mentor
    Jan Schilbach [jan.schilbach(at)uni-leipzig.de]

Ruby Extractor

Facilitation of Parsing

  • Brief explanation
    Currently the Ruby behaviour parser of Getaviz needs the instrumentation of the ruby code to start the tracing at a specific point. It is desireable to provide a possibility for the user of the behaviour parser to determin the start and end of the tracing as an command line argument.

  • Expected results

    • Package structure, behavior and evolution parser as a gem with binaries
    • Provide suitable command line options for all parsers for output files and for git repos as input
    • Provide command line options to the behavior parser to determine either the source code file and line or the class an method where the tracing starts and where it should finish
    • Provide suitable filter options for all parsers
    • Create unit tests for all parsers

  • Involved Technologies
    Ruby

  • Knowledge Prerequisite
    Experience with at least one high-level language, e.g. Ruby or Java.

  • Mentor
    Jan Schilbach [jan.schilbach(at)uni-leipzig.de]

Clone this wiki locally