Refactoring class hierarchies with KABA

Streckenbach, Mirko; Snelting, Gregor

doi:10.1145/1028976.1029003

Cited by 40 publications

(19 citation statements)

References 16 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…As a result, they propose a new class hierarchy that is behaviorally equivalent to the original one. The implementation of this approach for refactoring Java class hierarchies is proposed by Streckenback et al, [73] using KABA. Additionally, the transformed hierarchy can then be subject to further manual refactorings, while the semantics are guaranteed to be preserved.…”

Section: Understanding (And Evolution) Of Class Hierarchiesmentioning

confidence: 99%

Generating a catalog of unanticipated schemas in class hierarchies using Formal Concept Analysis

Arévalo

Ducasse

Gordillo

et al. 2010

Information and Software Technology

View full text Add to dashboard Cite

Context: Inheritance is the cornerstone of object-oriented development, supporting conceptual modeling, subtype polymorphism and software reuse. But inheritance can be used in subtle ways that make complex systems hard to understand and extend, due to the presence of implicit dependencies in the inheritance hierarchy.Objective: Although these dependencies often specify well-known schemas (i.e., recurrent design or coding patterns, such as hook and template methods), new unanticipated dependency schemas arise in practice, and can consequently be hard to recognize and detect. Thus, a developer making changes or extensions to an object-oriented system needs to understand these implicit contracts defined by the dependencies between a class and its subclasses, or risk that seemingly innocuous changes break them. Method:To tackle this problem, we have developed an approach based on Formal Concept Analysis. Our FoCARE methodology (Formal Concept Analysis based-Reverse Engineering) identifies undocumented hierarchical dependencies in a hierarchy by taking into account the existing structure and behavior of classes and subclasses.Results: We validate our approach by applying it to a large and non-trivial case study, yielding a catalog of Hierarchy Schemas, each one composed of a set of dependencies over methods and attributes in a class hierarchy. We show how the discovered dependency schemas can be used not only to identify good design practices, but also to expose bad smells in design, thereby helping developers in initial reengineering phases to develop a first mental model of a system. Although some of the identified schemas are already documented in existing literature, with our approach based on Formal Concept Analysis (FCA), we are also able to identify previously unidentified schemas. * Principal corresponding author Conclusions: FCA is an effective tool because it is an ideal classification mining tool to identify commonalities between software artifacts, and usually these commonalities reveal known and unknown characteristics of the software artifacts. We also show that once a catalog of useful schemas stabilizes after several runs of FoCARE, the added cost of FCA is no longer needed.

show abstract

Section: Understanding (And Evolution) Of Class Hierarchiesmentioning

confidence: 99%

Generating a catalog of unanticipated schemas in class hierarchies using Formal Concept Analysis

Arévalo

Ducasse

Gordillo

et al. 2010

Information and Software Technology

View full text Add to dashboard Cite

show abstract

“…KABA [24] uses static and dynamic analysis about the clients of classes to refactor class hierarchies. For each object creation site, a new class is created.…”

Section: Related Workmentioning

confidence: 99%

A software metric for coherence of class roles in Java programs

Mäkelä

Leppänen

2007

Proceedings of the 5th International Symposium on Principles and Practice of Programming in Java - PPPJ '07

View full text Add to dashboard Cite

The purpose of software metrics is to measure the quality of programs. The results can be for example used to predict maintenance costs or improve code quality. An emerging view is that if software metrics are going to be used to improve quality, they must help in nding code that should be refactored. Often refactoring or applying a design pattern is related to the role of the class to be refactored. In clientbased metrics, a project gives the class a context. These metrics measure, how a class is used by other classes in the context. We present a new client-based metric LCIC (Lack of Coherence in Clients), which analyses, if the class being measured has a coherent set of roles in the program. Interfaces represent the roles of classes. If a class does not have a coherent set of roles, it should be refactored, or a new interface should be dened for the class.We have implemented a tool for measuring the metric LCIC for Java projects in the Eclipse environment. We calculated LCIC values for classes of several open source projects. We compare these results with results of other related metrics, and inspect the measured classes to nd out, what kind of refactorings are needed. We also analyse the relation of dierent design patterns and refactorings to our metric. Our experiments reveal the usefulness of client-based metrics to improve the quality of code.

show abstract

“…Its effect appears to be roughly the same as that of global type inference in the spirit of [12]. Streckenbach & Snelting have only recently applied this algorithm to the refactoring of JAVA programs, automatically changing all type references (including instantiations) in a program (the KABA system) [17]. KABA also offers a refactoring tool for collapsing and manually reorganizing the produced type hierarchy, but this operates on (compiled) byte code of an application.…”

Section: Refactoring and Type Inferencementioning

confidence: 99%

“…For this, new subclasses must be introduced, which is why the work is also referred to as program [17] or class hierarchy specialization [19]. KABA uses points-to analysis to identify specialization candidates; due to its approximating nature, this introduces certain artifacts [17].…”

Section: Refactoring and Type Inferencementioning

confidence: 99%

Decoupling classes with inferred interfaces

Steimann

Mayer

Meißner

2006

Proceedings of the 2006 ACM Symposium on Applied Computing

View full text Add to dashboard Cite

Using small, context-specific interfaces in variable declarations serves the decoupling of classes and increases a program's flexibility. To minimize its interface, a thorough analysis of the protocol needed from a variable is required. Currently available refactorings for the extraction of interfaces leave the programmer alone with the decision which methods to include or, more problematically, which to omit: they let him choose manually from the protocol of an existing type, and only then offer to use the new interface where (if) possible. To aid the programmer in defining a new interface, we have developed a new refactoring that infers it from a variable's declaration and automatically inserts it into the code.

show abstract

Refactoring class hierarchies with KABA

Cited by 40 publications

References 16 publications

Generating a catalog of unanticipated schemas in class hierarchies using Formal Concept Analysis

Generating a catalog of unanticipated schemas in class hierarchies using Formal Concept Analysis

A software metric for coherence of class roles in Java programs

Decoupling classes with inferred interfaces

Contact Info

Product

Resources

About