Maintaining software systems requires up-to-date models of these systems to systematically plan, analyse and execute
the necessary reengineering steps. Often, no or only outdated models of such systems exist. Thus, a reverse engineering step is
needed that recovers the system’s components, subsystems and connectors. However, reverse engineering methods are severely impacted by design deficiencies in the system’s code base, e.g., they lead to wrong component structures. Several approaches exist today for the reverse engineering of component-based systems,
however, none of them explicitly integrates a systematic design deficiency removal into the process to improve the quality of the reverse engineered architecture. Therefore, in our Archimetrix approach, we propose to regard the most relevant deficiencies with respect to the reverse engineered architecture and support reengineers by presenting the architectural consequences of removing a given deficiency. We validate our approach on the Common Component Modeling Example and show that we are able to identify relevant deficiencies and that their removal leads to an improved reengineered architecture.

During the software lifecycle, software systems have to be continuously maintained to counteract architectural deterioration and retain their software quality. In order to maintain a software it has to be understood first which can be supported by (semi-)automatic reverse engineering approaches. Reverse engineering is the analysis of software for the purpose of recovering its design documentation, e.g., in form of the conceptual architecture. Today, the most prevalent reverse engineering approaches are (1) the clustering-based approach which groups the elements of a given software system based on metric values in order to provide an overview of the system and (2) the pattern-based approach which tries to detect pre-defined patterns in the software which can give insight about the original developers' intentions.
In this paper, we present an approach towards combining these techniques: we show how the detection and removal of certain bad smells in a software system can improve the results of a clustering-based analysis.
We propose to integrate this combination of reverse engineering approaches into a reengineering process for component-based software systems.

Software maintenance tasks require knowledge about the software’s design. Several tools help to identify implementations of software patterns, e.g. Design Patterns, in source code and thus help to reveal the underlying design. In case of the reverse engineering tool suite Reclipse, detection algorithms are generated from manually created, formal pattern specifications. Due to numerous variants that have to be considered, the pattern specification is error-prone.Because of this, the complex, step-wise generation process has to be traceable backwards to identify specification mistakes. To increase the traceability, we directly interpret the detection algorithm models (story diagrams) instead of executing code generated from these models.This way, a reverse engineer no longer has to relate generated code to the story diagrams to find mistakes in pattern specifications.

In reverse engineering, dynamic pattern detection is accomplished by collecting execution traces and comparing them to expected behavioral patterns. The traces are collected by manually executing the program in question and therefore represent only part of all relevant program behavior. This can lead to false conclusions about the detected patterns. In this paper, we propose to generate all relevant program traces by using symbolic execution. In order to reduce the created trace data, we allow to limit the trace collection to a user-selectable subset of the statically detected pattern candidates.

Reverse Engineering, i.e. the analysis of software for the purpose of recovering its design documentation, e.g. in form of the conceptual architecture, is an important area of software engineering. Today, two prevalent reverse engineering approaches have emerged:(1) the clustering-based approach which tries to analyze a given software system by grouping its elements based on metric values to provide the reverse engineer with an overview of the system and (2) the pattern-based approach which tries to detect predefined structural patterns in the software which can give insight about the original developers’ intentions. These approaches operate on different levels of abstraction and have specific strengths and weaknesses.In this paper, we sketch an approach towards combining these techniques which can remove some of the specific shortcomings.

Reverse engineering tools can simplify the recovery of a software system’s design by detecting design pattern implementations. This helps to understand a software system andthereby supports the process of maintaining or extending a software.Because the manual specification of patterns has to maintain the balance between precision and generality, detection results may contain incorrectly detected pattern implementations.Usually, a detected candidate cannot be displayed in detail so that interpreting the detection results is difficult. In this paper, we present an approach for a comprehensive and comprehensible visualization of detection results in the reverse engineering tool suite Reclipse.

The detection of software design pattern implementations in existing code helps reverse engineers to understand the software design and the original developers’ intentions. In order to automate the tedious and time-consuming task of finding pattern implementations several research groups developed pattern detection algorithms and reported their precision and recall values to compare the approaches.
Our research group developed another approach for the detection of software patterns, Reclipse, that exhibits some unique features like fuzzy expressions to better describe patterns and rate the detected pattern occurrences. For evaluation, we applied our pattern detection approach to JHotDraw. In the following, we present and compare our pattern detection results with those of other approaches.

Design pattern detection is a reverse engineering methodology that helps software engineers to analyze and understand legacy software by recovering design decisions and thereby providing deeper insight into software. In this report we present Reclipse, a reverse engineering tool suite based on Fujaba. Reclipse provides static and dynamic design pattern detection in combination with a pattern rating that is used to evaluate the quality of our detection results.

Design pattern detection is a reverse engineering methodology that helps software engineers to analyze and understand legacy software by recovering design decisions and thereby providing deeper insight into software. Recent research has shown that a combination of static and dynamic source code analysis can produce better results than purely static approaches.
In this paper we present an extension of the pattern detection approach proposed by Wendehals. In particular, we extend the specication language for behavioral patterns to increase its expressiveness and the approach's recall by introducing the concept of set objects.

The paper presents a further step of the Fujaba Tool Suite RE to support coarse-grained analyses based on metrics and especially polymetric views. Polymetric views are graphical representations of certain metric combinations. Following an interactive reverse engineering approach, polymetric views can be created on demand. The reverse engineer is able to define new polymetric view descriptions and create new views afterwards.

Reverse engineering based on dynamic analyses often uses method traces of the program under analysis. Recording all method traces during a program's execution produces too much data, though for most analyses, a 'slice' of all method traces is sufficient. In this paper, we present an approach to collect runtime information by selectively recording method calls during a program's execution. Only relevant classes and methods are monitored to reduce the amount of information. We developed the JavaTracer which we use for the recording of method calls in Java programs.

Design recovery, which means extracting design documents from source code, is usually done by static analysis techniques. Analysing behaviour by static analysis is very imprecise. We combine static and dynamic analysis to increase the preciseness of our design recovery process. In this paper we present an approach to collect data for the dynamic analysis by recording method calls during a program's execution. To reduce the amount of information we monitor only relevant classes and methods identified by static analysis.

Today, in software intensive projects a huge amount of the budget flows into the analysis of the already existing system. The reason for the high costs results mainly from the fact that analyses are often made manually or with automatic tool support, which is inappropriate for analyzing large systems. Semi-automatic analysis approaches usually use a notion of fuzziness to overcome this limitation, but inherit the problem of selecting appropriate initial values. In this paper we present an approach to adapt the initial values of our semi-automatic reverse engineering process. We provide the reverse engineer with accuracy information for results produced by a rule-based inference algorithm. Based on the changes of the results done by the reverse engineer we automatically adapt a credibility value of each rule, which previously has been used to compute the accuracy of the result. The adaption fits seamlessly into our overall analysis process. First tests show that it is suitable for the calibration of our fuzzyfied rule-based pattern recognition approach.

Reverse engineering is a process highly influenced by assumptions and hypotheses of a reverse engineer, who has to analyse a syste
m manually, because tools are often not applicable to large systems with many different implementation styles. Successful tools have to support an interactive process, where the engineer is able to steer the analysis process by proving certain assumptions and hypotheses. Consequently, the input format of the analysis tool must support a kind of impreciseness to formulate weak presumptions. In this paper we present a reverse engineering process based on fuzzy graph transformation rules. We use graph rewrite rules in addition with fuzzy logic to detect design patterns in Java source code. Impreciseness is expressed by assigning fuzzy values to graph transformation rules and thresholds are used to look up only firmed occurrences of patterns. Underlying the transformation rules is an object-oriented graph model providing composition and inheritance, which reduces the complexity of the rules. We propose a reverse engineering process starting with imprecise rules and refining and specifying the rules during the analysis. Preliminary results applying our process are promising, i.e., we present the results of detecting design patterns in Java's Abstract Window Toolkit (AWT) library.

Large industrial legacy systems are challenges of reverse-engineering activities. Reverse-engineering approaches use text-search tools based on regular expressions or work on graph representations of programs, such as abstract syntax graphs. Analyzing large legacy systems often fail because of the large search space. Our approach to handle large search space in pattern-based reverse engineering is to allow imprecise results in means of false positives. We use the theory of fuzzy sets to express impreciseness and present our approach on the example of recovering associations.

Design pattern instance recognition is often done by static analysis, thus approaches are limited to the recognition of static parts of design patterns. The dynamic behavior of patterns is disregarded and leads to lots of false positives during recognition. This paper presents an approach to combine the advantages of static and dynamic analyses to overcome this problem and improve the design pattern instance recognition.