Projects

Sketching is an important activity for understanding, designing and communicating different aspects of software systems such as their requirements or architecture. Often, sketches start on paper or whiteboards, are revised, and may finally evolve into a digital version. During this lifecycle, previous revisions and context information may get lost. Moreover, sketches are not isolated but may be related to other sketches or documents. In this paper, we present LivelySketches, a tool that supports the lifecycle of sketches by enabling users to capture both analog and digital sketches as well as relevant context information. In addition, the tool allows to link sketches to each other or other related documents.

Humans are very efficient in processing and remembering visual information. That is why metaphors and visual representations are important in education. Because of their high visual expressiveness, presentation tools like Microsoft PowerPoint are very popular for teaching in classrooms. However, representing source code with such tools is tedious and cumbersome, while alternatives like source code editors lack visual expression. Moreover, modifying prepared content, e.g. while responding to questions, is not well supported. In this paper, we introduce VisualCues, an approach with the goal of combining the flexibility of source code editors with the visual expressiveness of classical slide-based presentation tools. A key concept of VisualCues is linking visual artifacts to specific elements of source code. The main advantage is that when changing the underlying source code, the positions of linked visual artifacts are changed simultaneously. We implemented a first prototype and evaluated it in two undergraduate computer science courses.

Sketches and diagrams play an important role in the daily work of software developers. If they are archived, they are often detached from the source code they document, because there is no adequate tool support to assist developers in capturing, archiving, and retrieving sketches related to certain source code artifacts. We implemented SketchLink to increasing the value of sketches and diagrams created during software development by supporting developers in these tasks. Our prototype implementation provides a web application that employs the camera of smartphones and tablets to capture analog sketches, but can also be used on desktop computers to upload, for instance, computer-generated diagrams. We also implemented a plugin that embeds the links in Javadoc comments and visualizes them in situ in the source code editor as graphical icons for the IntelliJ Java IDE. Besides being a useful software documentation tool, SketchLink also enables developers to navigate through their source code using the linked sketches and diagrams.

Model Fusion - Interactive Merging of Graph-Based, Visual Models

Most software systems are designed and developed in teams. Especially during the early phases of the development process, variants of design models are created that need to combined in a subsequent step. Due to semantic dependencies, inconsistent changes, or missing information, the process of combining such models may only be automated to some extend. Thus, developers are required to solve conflicts manually. Often, they also change or even extend models additionally. We call this process model fusion as it is going beyond a pure combination or merging of models.
The goal of this project is to better understand how developers combine graph-based, visual models especially those that show semantic differences. Based on this, we plan to develop tools that support developers when comparing and merging models. To this end, we resort to different visualization and interaction techniques.

Multi-Dimensional Coupling Analysis

A software system can be regarded as a complex web of code artifacts. Couplings between the code artifacts represent the references, calls, dependencies, imports, and similarities of the system. Together, these different coupling concepts form a multi-dimensional model of the software system. The goal of this research project is to analyze and exploit the multi-dimensional structure of software systems. In contrast to related research, the focus of this project is on the various concepts of code coupling rather than on investigating a single coupling concept for a particular application.

JCCD

A code clone is a code fragment in source code which is identical or similar to another code fragment. JCCD (Java Code Clone Detection API) facilitates to build custom code clone detectors. Such a code clone detector can be easily integrated into other Java applications. JCCD is based on a generic pipeline model which coordinates the interplay of all required steps in a code clone detection process. Without exception, every step of the pipeline implementation can be supplemented or replaced by alternative approaches. Thus, JCCD enables a highly configurable and extensible code clone detection.

http://jccd.sourceforge.net/

Collaborative Requirements Engineering

Requirements for a software system provided by customers are often vague, incomplete, or do not match the vocabulary of the requirements engineers. CRC sessions involve all stakeholders and facilitate the design of a software system. Therefore, a group of software engineers and domain experts gather in the same room and develop and evaluate an object-oriented model by using so called CRC cards.
In order to improve this procedure, we developed CREWW and CREWSpace. Both tools enable collaborative requirements engineering with digital CRC cards, but leverage different input devices. While CREWW uses Wii-Remotes to allow simultaneous access to a shared virtual artifact, CREWSpace leverages mobile devices like smartphones or tablets. Thus, in the latter case, users are also able to access a private workspace.

http://www.st.uni-trier.de/crewspace/

http://www.st.uni-trier.de/creww/

TimeRadarTrees

The evolution of dependencies in information hierarchies can be modelled as a sequence of a certain kind of graphs, so-called compound digraphs. The sequences can either be visualized using traditional, animated node-link diagrams or with our novel approach calld TimeRadarTrees. The TimeRadarTree visualization technique uses a radial tree layout to represent the hierarchy and circle arcs and sectors to represent the edges (dependencies). Moreover, the edges can have weights based on application-specific metrics. The edge weights are color coded. Various interaction and navigation techniques help to analyse the visualized data.

ChartFlight

ChartFlight is a web service that utilizes Blender, a free open source 3D content creation suite, and its Python API to automatically generate three-dimensional chart flights.
Users simply provide a map or any kind of image, a set of locations restricted to that image, which define where to visualize data, and the data for every location itself. By means of a Python script to combine these information ChartFlight generates an animated flight across the map and visualizes the given data using three-dimensional chart. For a flexible use of such visualizations we set up ChartFlight to render videos, which can be downloaded after they have been processed.

Refactoring Detection

Refactoring Detection

We are concerned with the problem of reconstructing refactorings that occured during the evolution of a software system. This analysis can be helpful for improving the software engineering process. For example, detected refactorings can help the programmer to re-understand the program code after being absent for a certain time. Refactorings detected in software archives can also be used to identify errors that have occured during the software development. Futhermore, the refactoring information provides new insights how software projects evolve over time.

http://www.st.uni-trier.de/refactoring

In the "Software-Evolution" project, we analyze how software-systems, i.e. computer programs, change over time. With the knowledge gained we want to help developers to better understand their systems such that they work more efficient and produce fewer mistakes.  For example, we can show, what parts of a program have been moved different positions or have simply been renamed. Furthermore, we try to learn from the past: When some parts of a program have been frequently changed together, it will be very likely that in the future these parts have to be changed together as well. 

http://www.st.uni-trier.de/eposoft/

The dynamics of a network can sometimes express more than the network itself. This insight itself doesn’t really help, if the necessary analysis tools are missing: tools which make the evolution of the network understandable. In the project DGD we address this problem. We develop a tool to render the dynamics of a network visible and perform detailed analyses. For further information see:

 http://www.st.uni-trier.de/DGD

Crater

Until now teachers and lecturers had to rely on questionable Hollywood movies and bad documentary films to get a graphic picture of the processes during an impact. The CRATER website tries to give a sound standing insight into the topic with the help of background information and a computer simulation based on mathematical and scientific methods.