Understanding the use of inheritance with visual patterns

Denier, Simon; Sahraoui, Houari

doi:10.1109/esem.2009.5316016

Cited by 6 publications

(3 citation statements)

References 15 publications

(18 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Then, it remains a rather global metric and shares the same other shortfalls as the MIF metric. Sahraoui and Denier [5] proposed a visual representation of some metrics related to inheritance in a form called "sunburst layout". This visualization uses a radial space-filling technique: a sunburst map is a circle with slices and sub-slices representing hierarchies.…”

Section: Related Workmentioning

confidence: 99%

Measuring Inheritance Patterns in Object Oriented Systems

Niculescu

Dugerdil

Canedo

2015

Proceedings of the 8th India Software Engineering Conference

View full text Add to dashboard Cite

Among the code structuration mechanisms in object oriented systems, class hierarchies based on the generalization relationship play a prominent role. Indeed it is used to represent and code hierarchies of abstractions supposed to help with code understanding, maintenance and extension. But it is common to see class hierarchies and the associated inheritance mechanism be diverted from this noble role to become a mere code sharing mechanism. In this case, rather than helping, the inheritance mechanism confuses the understanding of the code. Hence, we have developed a metric to analyze the inheritance mechanism at work in a running system, what we have called the inheritance pattern. Although the metrics measuring inheritance are numerous, our approach is original since it observes the actual inheritance in the running code at the class level as well as among the packages (i.e. among the classes through package). In some sense, this metric measures how well the inheritance mechanism has been leveraged in the software. But interpreting raw numbers can be hard. Then we developed a visual and hierarchical representation of the metric values at the scale of a whole system. This helps to assess the quality of the code from the point of view of code abstraction.

show abstract

Section: Related Workmentioning

confidence: 99%

Measuring Inheritance Patterns in Object Oriented Systems

Niculescu

Dugerdil

Canedo

2015

Proceedings of the 8th India Software Engineering Conference

View full text Add to dashboard Cite

show abstract

“…With this approach, the engineer can perform the analysis and browse the code to validate his hypotheses. Focusing on class hierarchy understanding, Denier et al, [21] propose a similar approach. They provide a compact view of class hierarchies using a custom Sunburst layout.…”

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

“…Identifying which metrics can be used depends on the intent of visualization. The code-related metrics which has been frequently used for visualization purposes are: line of codes (LOC), McCabe complexity [39] and number of methods (NOM) [40], [41]. These metrics support the maintainability of source code.…”

Section: Visualization Of Source Codementioning

confidence: 99%

Towards Visualization of Unit Test and Source Code Relations

Aljawabrah

View full text Add to dashboard Cite

Test-to-code traceability is the ability to relate the test unit and source code artifacts created during the software development life cycle (SDLC). Traceability of test and code relations is fundamental to support various activities of software development such as program comprehension, verification and validation, impact analysis, reuse, maintenance, and software evolution. Notwithstanding its importance, many significant challenges are associated with traceability. One of these challenges is how to support the comprehension and maintenance of these links efficiently and effectively.Visualization is an important part that effectively supports understanding test-tocode relations. It provides enhanced process visibility, helps engineers, developers, and testers to verify the quality of TCT links, and understand which code modules are tested by which unit tests.As there are many sources from where the traceability relations can be inferred, one of the most important questions is to decide which source or combination of sources is the best to determine the test-to-code links. It is obvious that, if these sources disagree, this will make it harder to understand what is going on, what was the goal of the developer, and how the components are really related and change impact analysis can yield false results, etc. Fortunately, visualization can aid this task. The presented approach consists of three parts. The first part consists of the recognition of artifacts from two different areas, source code, and unit test. The second part presents different sources for capturing the links between code and test iv such as a naming convention, last call before assert, and the static call graph. The third part includes the visualization method used to visually present the traceability links inferred from traceability links sources. The trace visualization approach is implemented as a trace visualization tool, which is called TCTracVis.This thesis also provides an empirical study based on the implementation of the presented approach. The approach and its tool support are applied in different software development projects conducted with a group of students, academics, and from industry. The effectiveness and practicability of the presented approach and its tool support have been evaluated. The effectiveness results indicate that the visualization of multilevel test-to-code traceability links, inferred from multiple sources, is more effective for the testers and developers than using visualization of a single source of traceability links. It helps to get a bigger picture of what is going on with the tests, find solutions to the problems in testing, and understand the relationships between test cases and the corresponding units under test. At the same time, the usability results indicate that the participants found that the approach and its tool support usability, and enhance the overall browsing, comprehension, and maintenance of test-to-code traceability links of a system.

show abstract

Understanding the use of inheritance with visual patterns

Cited by 6 publications

References 15 publications

Measuring Inheritance Patterns in Object Oriented Systems

Measuring Inheritance Patterns in Object Oriented Systems

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

Towards Visualization of Unit Test and Source Code Relations

Contact Info

Product

Resources

About