Onthefly extraction of hierarchical object graph

Authors: Hugo de Brito Humberto Torres MarquesNeto Ricardo Terra Henrique Rocha Marco Tulio Valente

Publish Date: 2013/03

Volume: 19, Issue: 1, Pages: 15-

PDF Link

Abstract

Reverse engineering techniques are usually applied to extract concrete architecture models However these techniques usually extract models that just reveal static architectures such as class diagrams On the other hand the extraction of dynamic architecture models is particularly useful for an initial understanding on how a system works or to evaluate the impact of possible maintenance tasks This paper describes an approach to extract hierarchical object graphs OGs from running systems The proposed graphs have the following distinguishing features a they support the summarization of objects in domains b they support the complete spectrum of relations and entities that are common in objectoriented systems c they support multithreading systems and d they include a language to alert about expected or unexpected relations between the extracted objects We also describe the design and implementation of a tool for visualizing the proposed OGs Finally we provide two case studies The first study shows how our approach can contribute to understand the running architecture of two systems myAppointments and JHotDraw The second study illustrates how OGs can help to locate defective software components in the JHotDraw systemA common definition or view describes software architecture as the main components of a system including the acceptable and unacceptable relations among them 7 13 20 However despite their unquestionable importance architectural models and abstractions are usually not documented or when they are the available documentation normally does not reflect the actual architecture followed by the implementation of the target systems 9 16 19In such scenarios reverse engineering techniques can be applied to reify information about a target system architecture 10 27 Usually those techniques extract models that reveal the static architecture including class and package diagrams 12 or dependency structure matrices 22 As one of their distinguishing advantages static models can be retrieved directly from the source code ie without requiring the execution of the target system However static models only show a partial snapshot of the relations connections and dependencies that are actually established during the execution of the modeled system For example static diagrams cannot reveal relations due to polymorphism dynamic method calls or reflection Furthermore they do not include information on the order in which the represented relations are established In other words static diagrams do not provide a clear roadmap to developers that need to understand a given system Finally static diagrams do not take into account relations and dependencies established by distinct threads which makes the task of understanding concurrent systems complexOn the other hand reverse engineering techniques can also be applied to extract models that reveal dynamic architectures such as object and sequence diagrams 12 Dynamic diagrams explicitly represent the control flow of the target system and therefore they provide an order that can be followed when initially reasoning about the system Moreover dynamic diagrams can express relations due to polymorphism or reflection 23 29 In contrast dynamic diagrams present major problems regarding their scalability Because they typically do not make any distinction between lowerlevel objects such as instances of javautilDate and architectural relevant objects such as collections of Customer objects dynamic diagrams may have thousands of nodes even for smallsized systems 1 2The available solutions to increase the scalability of dynamic diagrams are centered on the same principle to group objects into coarsegrained and hierarchical structures In the highest level of such structures only architectural relevant groups of objects are displayed usually called domains 1 components 18 clusters 5 etc It is also possible to expand such higherlevel groups to provide more details about their elements This process can be repeated several times until reaching a flat object graph OG where each node corresponds to a runtime object Basically there are two approaches to group objects into coarsergrained structures automatic approaches for example using clustering algorithms 5 6 and manual approaches for example using annotations 1 2 Typically automatic solutions do not derive groups of objects similar to those expected by the system’s architects and maintainers On the other hand solutions based on annotations are invasive requiring the annotation of each architectural relevant class for example the classes of the Model layer must be annotated with a Model annotationThis paper is a revised and extended version of a previous conference paper presenting an onthefly and noninvasive approach to extract hierarchical OGs from running systems 4 It also describes a noninvasive tool to extract and display the proposed graphs This tool can be plugged to existing systems and thus it supports the onthefly visualization of the proposed graphs ie the graphs are displayed and updated as the host system executes This property distinguishes the proposed tool from other reverse engineering systems where it is usually required to first execute the target system to generate a trace that is then displayed offline Finally we report two case studies on using OGs The first study illustrates how the proposed OGs and supporting tool can help to recover and to reason about the dynamic architecture of two systems myAppointments a personal information manager system and JHotDraw a wellknown framework for creating drawing applications The second study describes how OGs can help to locate the defective software components responsible for an incorrect behavior in the JHotDraw system as reported in real corrective maintenance requests retrieved from JHotDraw’s bug tracking platformThe remainder of this paper is organized as follows Section 2 describes the proposed OGs including a description on their main elements and examples Section 3 describes the language used to define visual alerts when expected or unexpected dynamic relations are established in the extracted OGs Section 4 presents the OG tool that extracts and displays OGs In Sect 5 we present the first case study on extracting dynamic architectures Section 6 presents the second study on the use of OGs in real JHotDraw’s corrective maintenance tasks Finally Sect 7 discusses related work and Sect 8 concludes the paperThe graphs proposed in the paper have been designed to support the following requirements a they should be able to express the different types of relations available in objectoriented systems including relations due to dynamic calls and reflection b they should support the creation of coarsegrained groups of objects to increase readability and scalability c they should provide means to distinguish objects created by different threads d in order to provide support to dynamic architecture conformance it should be possible to highlight relations that are expected—or that are not expected—when running a system Finally it should be possible to extract OGs from running systems in a noninvasive way

Keywords: