A new method is presented for analyzing and reengineering class hierarchies. In our approach, a class hierarchy is processed along with a set of applications that use it, and a fine-grained analysis of the access and subtype relationships between objects, variables and class members is performed. The result of this analysis is again a class hierarchy, which is guaranteed to be behaviorally equivalent to the original hierarchy, but in which each object only contains the members that are required. Our method is semantically well-founded in concept analysis: the new class hierarchy is a minimal and maximally factorized concept lattice that reflects the access and subtype relationships between variables, objects and class members. The method is primarily intended as a tool for finding imperfections in the design of class hierarchies, and can be used as the basis for tools that largely automate the process of reengineering such hierarchies. The method can also be used as a space-optimizing source-to-source transformation that removes redundant fields from objects. A prototype implementation for Java has been constructed, and used to conduct several case studies. Our results demonstrate that the method can provide valuable insights into the usage of the class hierarchy in a specific context, and lead to useful restructuring proposals.

Reverse engineering software systems has become a major concern in software industry because of their sheer size and complexity. This problem needs to be tackled, since the systems in question are of considerable worth to their owners and maintainers. In this article we present the concept of a polymetric view, a lightweight software visualization technique enriched with software metrics information. Polymetric views help to understand the structure and detect problems of a software system in the initial phases of a reverse engineering process. We discuss the benefits and limits of several predefined polymetric views we have implemented in our tool CodeCrawler. Moreover, based on clusters of different polymetric views we have developed a methodology which supports and guides a software engineer in the first phases of a reverse engineering of a large software system. We have refined this methodology by repeatedly applying it on industrial systems, and illustrate it by applying a selection of polymetric views to a case study.

The increased popularity of the object-oriented paradigm has also increased the interest in object-oriented reengineering. First of all, object-oriented software systems suffer from similar maintainability problems as traditional procedural systems, displaying the need for reengineering techniques tailored to deal with ob- ject-oriented code. Secondly, the increased importance of iterative development processes make reengi- neering techniques valuable in forward engineering, and thus for all paradigms that software is developed in. Reengineering requires tool support to deal with the large amounts of information and the wide variety of tasks to be performed. An important consideration in building tool environments for reengineering is what information must be provided and how this information is modelled. Design choices have a consider- able impact not only on the ability to support reengineering tasks, but also on issues such as scalability and tool interoperability. Several metamodels exist that model software for the purposes of reengineering. How- ever, they generally lack a discussion of the relevance of information for reengineering and the trade-offs of modeling alternatives. This thesis presents FAMIX, a language-independent metamodel for modelling object-oriented soft- ware for reengineering purposes. We discuss the exact contents of the metamodel, including its relevance for reengineering and how the metamodel supports the different object-oriented languages through its lan- guage-independent core. We also discuss the infrastructural design decisions of FAMIX by placing it into a design space for infrastructural aspects of reengineering repositories and metamodels. The design space presents multiple interdependent aspects, their design alternatives and how these impact issues such as scal- ability, extensibility and information exchange. We validate the ability of FAMIX to support reengineering on a language-independent level in two ways. First, we present Moose, a reengineering tool environment with a repository based on FAMIX. Moose serves as a foundation for multiple reengineering tools and has been applied to reverse engineer several large industrial case studies. Secondly, we define a set of fifteen low-level refactorings in terms of the infor- mation available in FAMIX. Refactoring requires sufficient, complete and 100% correct information as well as a clear interpretation of the supported languages in the language-independent core of the metamod- el, in order to correctly perform transformations on the language-specific code level. As such the refactor- ings provide an in-depth validation of the language independence of FAMIX.

A new method is presented for analyzing and reengineering class hierarchies. In our approach, a class hierarchy is processed along with a set of applications that use it, and a fine-grained analysis of the access and subtype relationships between objects, variables, and class members is performed. The result of this analysis is again a class hierarchy, which is guaranteed to be behaviorally equivalent to the original hierarchy, but in which each object only contains the members that are required. Our method is semantically well-founded in concept analysis: the new class hierarchy is a minimal and maximally factorized concept lattice that reflects the access and subtype relationships between variables, objects and class members. The method is primarily intended as a tool for finding imperfections in the design of class hierarchies, and can be used as the basis for tools that largely automate the process of reengineering such hierarchies. The method can also be used as a space-optimizing source-to-source transformation that removes redundant fields from objects. A prototype implementation for Java has been constructed, and used to conduct several case studies. Our results demonstrate that the method can provide valuable insights into the usage of a class hierarchy in a specific context, and lead to useful restructuring proposals.

The industry is nowadays confronted with large-scale monolithic and inflexible object-oriented software. Because of their high business value, these legacy systems must be reengineered. One of the important issues in reengineering is the detection and location of the design flaws, which prevent an e#cient maintenance and further development of the system. In this paper we present a metrics-based approach for detecting design problems, and we describe two concrete techniques for the detection of two well-known design flaws found in the literature. We apply our technique on an industrial case-study and discuss the findings. The experiment shows that the proposed technique found indeed real flaws in the system and it suggests that, based on the same approach, further detection techniques for other common design-flaws cand be defined.

The reverse engineering of large scale object-oriented legacy systems is a challenging task with a definite need for approaches helping to have a fast overview and to focus on the problematic parts. This paper investigates a hybrid approach, combining the immediate appeal of visualizations with the scalability of metrics. We validate our approach by showing how CodeCrawler, the experimental platform we built allowed us to reengineer some applications. Keywords: Reverse Engineering, Program Visualization, Software Metrics, CodeCrawler 1 Introduction "While the benefits of object-oriented technology are widely recognized, the indiscriminate use of object-oriented mechanisms and weaknesses in analysis and design methods are rapidly leading to a new generation of inflexible legacy systems." [4]. The ability to reverse engineer object-oriented legacy systems has become a vital matter in today's software industry. Early adopters of the object-oriented programming paradigm are now fa...

Understanding object-oriented legacy systems is a complex task exacerbated by the presence of late binding and polymorphism. Moreover, the metaphor of message sending and the anthropomorphism promoted by object-oriented languages makes it difficult to statically identify the precise role the objects play at run-time. We propose a lightweight visualization approach enriched with run-time information which allows us to identify precise aspects of the objects lifetime such as the role played in the creation of other objects and the communication architecture they support. Our approach not only supports the run-time understanding of an application but also allows one to evaluate test understanding and test coverage.

This research project is about reengineering object-oriented applications. Reengineering such applications inherits complex problems related to software maintenance, i.e., program understanding, program analysis, and program transformation and adds to them (1) the complexity introduced by late binding, dynamic typing, and incremental definition specific to object-oriented programming, and (2) the complexity related to the new way of software development (multiple parallel versions, frameworks, and products lines). Based on our research experience, this research project is structured in three non-orthogonal directions: (a) reengineering, (b) analysis of versions and (c) migration of object-oriented applications towards components.