Page Areas:



Additional Information:

Location

Science Park 3

We are located on the second floor of the Computer Science Building (Science Park 3) ...  more of Location (Titel)


Position Indication:

Content

seaxyz1234

Beschreibung:

Praktika

Visualization of Variability Realization

Software Product Lines (SPLs) are families of similar programs. The number of products and their complexity requires the adequate visualization to help designers make appropriate decisions. The goal of this project is to employ software visualization tools and techniques to depict both the individual products as well as the overall SPL in an interactive manner that allows users to navigate the variability space better.

Praktika

Visualizing Consistency Checking in Software Product Lines

Consistency checking verifies that certain conditions or properties hold in a group of software artifacts. Sometimes there is a large number of checks that are made with distinct result values. This number grows even larger as families of similar systems are considered (Software Product Lines). The goal of this project is to find useful ways to visualize the consistency checking results across all the family programs.

http://d3js.org/

Praktika and/or Thesis

Refactoring Guidance/Auto Completion

How can a computer provide guidance during your programming work? Imagine you have an algorithm that has knowledge over refactoring rules or patterns in general. Can you somehow make recommendations as to what the software engineer is doing? For example, your system might notice that a software engineer is separating out the functionality of an attribute into a separate class and suggest refactoring rules and patterns that

Praktika and/or Thesis

Incremental Transformation (Code and/or Model)

In model-driven software engineering, model transformations play a key role since they are used to automatically generate and update code and models from existing information. However, defining concrete transformation rules is a complex task because the designer has to cope with incompleteness, ambiguity, bidirectionality, and rule dependencies. The goal of this praktika is to implement a transformation between, say a model and code

Praktika

GUI for Traceability Capture and Visualization

provide a visualization for depicting traceability information. Traces reveal, for example, where in the code a requirement is implemented. We would like to have a GUI that allows us to capture and depict traceability information together with other artifacts. in the simple most case this could be a trace matrix or some kind of textual language. But also with the ability to add more information such as:

· call tree

· requirements regions

· method siblings (methods of same classes belonging together)

a special consideration should be given to the fact that trace matrices can be very large (incremental drawing) and that trace information may change continuously (incremental screen updating). A Model/View/Controller style implementation may be most appropriate. A basic infrastructure exists at this point

http://bost.ocks.org/mike/miserables/

http://bl.ocks.org/1308257

http://mbostock.github.com/d3/talk/20111116/bundle.html

Praktika and/or

How to Visualize Inconsistencies

Inconsistencies in models can span across multiple diagrams. When an inconsistency is detected, the least one can do is to highlight the elements involved in the inconsistency across these diagrams. However, can we do more? Can we filter diagrams to depict only the inconsistent information and what is directly relevant for it. Can we merge related diagrams or fragments of diagrams? Also relevant here could be to visualize inconsistencies only as relevant to the current work (what has changed lately, what is currently being looked at).
see also: A. Egyed: “Automatically Detecting and Tracking Inconsistencies in Software Design Models,” IEEE Transactions on Software Engineering (TSE), Volume 37, Number 2, March/April 2011, pp. 188-204.

Thesis (combination with Praktika possible)

Implementing Performance Antipatterns using ModelAnalyzer

Antipatterns describe scenarios that should be detected and prevented during software development. An example in Object Orientation is so called God Object which simply concentrates just too many functions in a single class object. Similarly, there has been work that describes a series antipatterns in performance models. The goal of the project is to implement these antipatterns with the tool support developed at our group, namely ModelAnalyzer, apply such implementation to multiple case studies and evaluate its effectiveness

 

Vittorio Cortellessa, Antinisca Di Marco, Catia Trubiani: Software Performance Antipatterns: Modeling and Analysis. 12th International School on Formal Methods for the Design of Computer, Communication, and Software Systems, SFM 2012, Bertinoro, Italy, June 18-23, 2012, pp. 290-335

Thesis (combination with Praktika possible)

Integrate DROOLS to Undo/Maintain Transformation

Imagine you generate some code from a model. We call this a transformation. And now imagine you change the model later. Now you need to also update the code. Of course, you could re-transform the model to code but what if you made changes to the code already. These might be lost. DROOLS is a truth maintenance engine. It helps you transform information where the model could be the transformation source and the code the transformation result. But DROOLS keeps track of the relationship between the transformation source and the result such that it is able to undo a transformation result if the source changes. So, if the models changes then DROOLS should be able to incrementally adapt the code.

Thesis

Mining Variability in Software Repositories

More and more commonly there are software repositories available for researchers and practitioners to study and analyze. However, there are has not been a comprehensive and systematic study of the potential or actual use of Software Product Lines (families of similar programs) in any of such repositories. The goal of the project is to use state-of-the-art software mining tools and techniques and apply them to existing repositories with the goal of identifying product lines and measure and characterize their features and evolution.