Many analyses of software systems can be formalized as relational queries, for example the detection of design patterns, of patterns of problematic design, of code clones, of dead code, and of differences between the as-built and the as-designed architecture. This paper describes the concepts of CrocoPat, a tool for querying and manipulating relations. CrocoPat is easy to use, because of its simple query and manipulation language based on predicate calculus, and its simple file format for relations. CrocoPat is efficient, because it internally represents relations as binary decision diagrams, a data structure that is well-known as a compact representation of large relations in computer-aided verification. CrocoPat is general, because it manipulates not only graphs (i.e. binary relations), but n-ary relations.

Large industrial legacy systems are challenges of reverseengineering 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.

A key problem during software development and maintenance is to detect and recognize recurring collaborations among software artifacts that are implicit in the code. These collaboration patterns are typically signs of applied idioms, conventions and design patterns during the development of the system, and may entail implicit contracts that should be respected during maintenance, but are not documented explicitly. In this paper we apply Formal Concept Analysis to detect implicit collaboration patterns. Our approach generalizes Antoniol and Tonella one for detecting classical design patterns. We introduce a variation to their algorithm to reduce the computation time of the concepts, a language-independent approach for object-oriented languages, and a post-processing phase in which pattern candidates are filtered out. We identify collaboration patterns in the analyzed applications, match them against libraries of known design patterns, and establish relationships between detected patterns and their nearest neighbours. 1.

Traceability links can provide essential support for evolutionary development of software, beyond requirements engineering e.g. for reuse & design decisions, design and code comprehension, effort estimation, checks for completeness and project management. For maximum support, traceability links are required not only for large grained artifacts but for fine grained ones as well. The establishment and the maintenance of these links is crucial, because inconsistent links prevent the aimed positive effects. However, a high effort for traceability links would inhibit the positive effects as well. In this paper, the state of the art approaches of definition and application of traceability links are investigated. They are integrated together with link update operations within development methods. The investigation and the integrated approach was evaluated in various projects in research and industry in the fields of both forward and reverse engineering.

Software engineering aims at techniques for producing better software products with less resources. A central concept for achieving this goal is a product line architecture. Frameworks are a popular object-oriented way to implement product line architectures. However, frameworks are often difficult to learn and their specializations consist of small and crosscutting logical entities that overlap with other design solutions of the software product. Implementation becomes fragmented, difficult to trace, and the original reasoning of the design is easily forgotten. Thus, the essential problems to be solved are the following: • How to teach the software developer to understand different frameworks and design principles in the context of her software product? • How to guide the software developer to use frameworks and product line architectures? • How to maintain and document implemented design solutions and framework specializations? In this

CrocoPat is an efficient, powerful and easy-to-use tool for manipulating relations of arbitrary arity, including directed graphs. This manual provides an introduction to and a reference for CrocoPat and its programming language RML. It includes several application examples, in particular from the analysis of structural models of software systems.

The decomposition of design patterns into simpler elements may reduce significantly the creation of variants in forward engineering, while it increases the possibility of identifying applied patterns in reverse engineering. Nevertheless, there are few reverse engineering tools that exploit the decomposition of patterns (i.e., FUJABA, SPQR). The SPQR approach introduces a catalog of elemental design patterns (EDP) and a rule set based on sigma-calculus through which EDPs are defined and composed into design patterns. Considering the SPQR approach particularly interesting, we propose a novel solution for defining and detecting EDPs and, further, design patterns. Our approach defines EDPs as logical functions of eight symbolic variables, each variable representing a method call (e.g., method name, method signature, method declaration, this reference, super reference) or a class property (superclass, same family, same object). An EDP detector has been developed based on this approach, representing a starting point for future developments towards design pattern recognition in the reverse engineering context. 1.

Current initiatives in the field of integrated development environment (IDE) and CASE tool integration such as Eclipse as well as the lately happened acquisitions of Rational and Together by major IDE vendors indicate that tool integration has become an important issue for the IT industry. However, as outlined in this paper the current integration platforms fall short to address the underlying problems of overlapping data models and their consistency when it comes to a tool integration. Within the Fujaba Tool Suite in contrast a framework has been developed which enables an integration of tools at the meta-model level. We report the employed concepts for meta-model integration and consistency management in this paper and illustrate them by means of an example.

Architecture and design patterns, as demonstrated solutions to recurring problems, have proved practically important and useful in the process of software development. They have been extensively applied in industry. Discovering the instances of architecture and design patterns from the source code of software systems can assist the understanding of the systems and the process of re-engineering. More importantly, it also helps to trace back to the original architecture and design decisions, which are typically missing for legacy systems. This paper presents a review on current techniques and tools for discovering architecture and design patterns from object-oriented systems. We classify different approaches and analyze their results. We also discuss the disparity of the discovery results from different approaches and analyze possible reasons with some insight. 1.

Abstract. Restructuring a program is a concept that aims at increasing the maintainability of a piece of code by changing its structure. The term refactoring is often used synonymously, especially when the observable behavior of a program should not change when transforming the structure of the software to a more sophisticated level, e.g. by using design patterns. Behaviour-conserving program transformations are difficult as the understanding of both the code to transform as well as the transformation is prerequisite for conserving the conduct of a transformed program. In addition, a transformation should only be executed if certain preconditions apply. To capture the semantic and syntactic details about a specific code fragment, it is proposed documenting them by adding machineprocessable and at the same time human-readable annotations. These annotations contain explicit information and could be added to source code by tools evaluating the code, as well as by practitioners. With annotations, it may be possible checking preconditions for program transformations to execute, and gain information necessary for these transformations.