Dirk Heuzeroth

Automatic design pattern detection

We detect design patterns in legacy code combining static and dynamic analyses. The analyses do not depend on coding or naming conventions. We classify potential pattern instances according to the evidence our analyses provide. We discuss our approach for the observer, composite, mediator, chain of responsibility and visitor patterns. Our Java analysis tool analyzes Java programs. We evaluate our approach by applying the tool on itself and on the Java SwingSetExample using the Swing library.

Generating design pattern detectors from pattern specifications

We present our approach to support program understanding by a tool that generates static and dynamic analysis algorithms from design pattern specifications to detect design patterns in legacy code. We therefore specify the static and dynamic aspects of patterns as predicates, and represent legacy code by predicates that encode its attributed abstract syntax trees. Given these representations, the static analysis is performed on the legacy code representation as a query derived from the specification of the static pattern aspects. It provides us with pattern candidates in the legacy code. The dynamic specification represents state sequences expected when using a pattern. We monitor the execution of the candidates and check their conformance to this expectation. We demonstrate our approach and evaluate our tool by detecting instances of the observer, composite and decorator patterns in Java code using Prolog to define predicates and queries.

Metaprogramming in the Large

Software evolution demands continuous adaptation of software systems to continuously changing requirements. Our goal is to cope with software evolution by automating program transformation and system reconfiguration. We show that this can be achieved with a static metaprogramming facility and a library of suitable metaprograms. We show that former approaches of program transformations are not sufficient for large object oriented systems and outline two base transformations that fill the gap.

Aspect-Oriented Configuration and Adaptation of Component Communication

In order to compose components, we have to adapt them. Therefore, we pursue a transformational approach focusing on the communication view. We show how to separate the definition of communication from the definition of other system aspects, how to extract this definition from existing systems, and how to weave it back into the system. Our main concern is the reconfiguration of this aspect.

COMPASS: tool-supported adaptation of interactions

This paper presents an aspect-oriented approach and tool to consistently exchange and adapt interactions among software units. This is done by first identifying components, their interactions and interaction patterns. Second, the identified interaction points of components are represented as aspect-oriented ports encapsulating the source elements related to the interaction. The interactions themselves are represented as first-class entities in the form of aspect-oriented connectors connecting the ports of components. These component, port and connector entities constitute an architectural model. Third, the developer reconfigures and adapts interactions exchanging the port and connector entities. This triggers corresponding source code transformations realized as meta programs using the Recoder tool. This approach is implemented as the COMPASS (COM position with aspects) tool, that can currently analyze and transform Java source code based on the infrastructure provided by the Recoder framework. The approach and tool are successfully validated replacing a direct method call between a producer and a consumer component by communication via a buffer object

Understanding Architecture through Structure and Behavior Visualization

Understanding the architecture of a legacy system is essential for the further development, the maintenance and the re-engineering of this system. Unfortunately, architecture is hardly documented in such systems. The only trustworthy source of information is the system implementation. Hence, the architecture has to be retrieved from this source. As real world legacy systems tend to be large, the source code cannot be read directly. Instead, we propose to use (semi-)automatic program analyses to extract the information.

ICSR7 Young Researchers Workshop

The workshop aims at providing a platform for young researchers in the software reuse community to present their work. Presentations of all participants will be commented by experienced panelists and briefly discussed. As a result, all participants will get useful guidance and fresh impetus to their ongoing research. The workshop serves as a forum for the participants to get in contact with other researchers in the field and to become familiar with other approaches and future research topics.