# Visualizing Object-oriented Software for Understanding and Documentation

Ra'fat Al-Msie'Deen

► To cite this version:

Ra'fat Al-Msie'Deen. Visualizing Object-oriented Software for Understanding and Documentation. International Journal of Computer Science and Information Security, 2015, 13 (5), pp.18-27. hal-04917814

HAL Id: hal-04917814

https://hal.science/hal-04917814v1

Submitted on 5 Feb 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>
Visualizing Object-oriented Software for
Understanding and Documentation

Ra'Fat AL-msie'deen

Department of Information Technology, Mutah University, Al-Karak, Jordan

**Abstract**—Understanding or comprehending source code is one of the core activities of software engineering. Understanding object-oriented source code is essential and required when a programmer maintains, migrates, reuses, documents or enhances source code. The source code that is not comprehended cannot be changed. The comprehension of object-oriented source code is a difficult problem solving process. In order to document object-oriented software system there are needs to understand its source code. To do so, it is necessary to mine source code dependencies in addition to quantitative information in source code such as the number of classes. This paper proposes an automatic approach, which aims to document object-oriented software by visualizing its source code. The design of the object-oriented source code and its main characteristics are represented in the visualization. Package content, class information, relationships between classes, dependencies between methods and software metrics is displayed. The extracted views are very helpful to understand and document the object-oriented software. The novelty of this approach is the exploiting of code dependencies and quantitative information in source code to document object-oriented software efficiently by means of a set of graphs. To validate the approach, it has been applied to several case studies. The results of this evaluation showed that most of the object-oriented software systems have been documented correctly.

**Keywords-** Vsound; software engineering; software documentation; software visualization; software understanding; software maintenance; software evolution; software reuse; change impact analysis; object-oriented source code; reverse engineering.

# I. INTRODUCTION

Different studies about the software understanding indicate that programmers rely on good software documentation [22]. Software rapidly becomes very complex when its size increases, which make its development very hard task. The very huge amount of information represented in the software source code, at all granularity levels (i.e., package, class, attribute and method) make understanding and documenting software a very difficult, lengthy, and error-prone task [3]. Moreover, manually-written documentation is not feasible for being incomplete, either because it is very time-consuming to create, or because it must frequently be updated [12]. This paper proposes a new approach called Vsound<fnref n="1" /> to understand and document the object-oriented (OO) software by visualizing its source code as a set of graphs at all granularity levels. In order to give a precise definition of the software

documentation, Vsound considers that the software documentation is the process of taking software source code and understanding it by visualizing its source code as a set of graphs.

Software visualization is the use of the crafts of typography, graphic design, animation, and cinematography with modern human-computer interaction and computer graphics technology to facilitate both the human understanding and effective use of computer software [13]. Software visualization (resp. software documentation) can tackle three different types of aspects of software (i.e., static, dynamic and evolution) [2]. The visualization of the static aspects of software focuses on visualizing software as it is coded. While, the visualization of the dynamic aspects of software represents information about a specific run of the software and helps comprehend program behavior and, at last, the visualization of the evolution of the static aspects of software adds the time factor to the visualization of the static aspect of software. This paper tackles only the visualization (resp. documentation) of the static aspects of software.

Software comprehension<fnref n="2" /> is the process whereby a software practitioner understands a software artifact using both knowledge of the domain and/or semantic and syntactic knowledge, to build a mental model of its relation to the situation [14]. Software understanding is one of the main software engineering activities. Software understanding is the process of taking software source code and understanding it. Software comprehension is necessary when a programmer migrates, reuses, maintains, documents or enhances software systems. Software that is not comprehended cannot be changed [1]. The domains of software documentation and visualization are driven by the need for program comprehension. Software visualization (resp. documentation) is a successful software comprehension way. Software comprehension is an important part of software evolution and software maintenance.

The software maintenance process is the most expensive part of software development. Most of time spent in software maintenance is used to comprehend the software code and the instructions that have to be changed [17]. Software maintenance is the modification of a software product after delivery to correct faults, to improve performance or other attributes, or to adapt the product to a changed environment [16]. The software undergoes modification to source code and related documentation due to a problem or the need for

<footnote n="1">¹ Vsound stands for Visualizing object-oriented Software for Understanding and Documentation.</footnote>

<footnote n="2">² a.k.a., "program understanding" or "source code comprehension".</footnote>
enhancement. The goal is to modify the existing software while preserving its integrity [15].

Software must frequently evolve to adjust to new features (resp. environments) or to meet specific requirements. Software system wants to evolve in order to be used longer time. The company often evolves frequent release of new versions of the original software. Each release results in the increase of software system size and complexity. Thus, software implementation that facilitates modify is key for reducing maintenance costs and effort. Software evolution reflects the process of progressive change in the attributes of the evolving entity or that of one or more of its constituent elements [20]. In other words, software evolution is linked to how software systems evolve over time.

Software reuse is important to reduce the cost and time of software development. In order to reuse existing source code there is a need to understand and document the software code. With increasing of software complexity (i.e., increasing count of lines of code) the need for reuse grows. Software reuse is the process of creating software systems from existing software rather than building software systems from scratch [18]. Software reuse helps reduce the development and maintenance effort. In addition, software reuse improves software quality and decrease time-to-market [38].

Software comprehending is very necessary for software changes in the maintenance stage. The changes to the software's code may be affected to another part of the code. These situations make the developer spent more time and effort to find the affected lines of the whole code. Change impact analysis is the process of identifying the potential consequences of a change, or estimate what needs to be modified to accomplish a change [21]. Change impact analysis support program understanding by finding the potential effect or dependency information in source code.

This paper proposes a new approach, which aims to document software systems by visualizing their code. The documentation process is very useful for software understanding, maintenance, evolution, reuse and changes. Documentation process involves the creation of alternative representations of the software, usually at a higher level of abstraction. It also involves analyzing the software in order to determine its elements and the relations between those elements. Software visualization is commonly used in the fields of reverse engineering and maintenance, where huge amount of code need to be understood [23]. Reverse engineering is the process of analyzing a subject system to identify the system's components and their interrelationships and create representations of the system in another form or at a higher level of abstraction [16].

To assist a human expert to document software system, this paper proposes an automatic approach, which generates a set of graphs (i.e., documents) using source code elements of a software system. Compared with existing work that documents source code (cf. section related work), the novelty of Vsound approach is that it exploits source code dependencies and its quantitative information, to document OO software in an efficient way by means of a set of graphs. Vsound accepts as

input the source code of software as a first step. Then, based on the static code analysis, Vsound generates an XML file contains the main source code elements (e.g., package, class attribute and method) and the dependencies (e.g., inheritance) between those elements. Next, Vsound documents the software by extracting a set of graphs based on the source code; each graph considers as a document. The mined documents cover all granularity levels (i.e., package, class, attribute and method) of the source code.

The Vsound approach is detailed in the remainder of this paper as follows. Section 2 briefly presents the background needed to understand the proposal. Section 3 shows an overview of Vsound approach. Section 4 presents the software documentation process step by step. Section 5 describes the experiments that were conducted to validate Vsound proposal. Section 6 discusses the related work, while section 7 concludes and provides perspectives for this work.

## II. BACKGROUND

This section provides a glimpse on software documentation and visualization. It also shortly describes dependencies between source code elements which consider relevant to Vsound approach.

The software documentation process aims to generate documents with abstract information based on software source code. The extracted documents are very useful, especially when software documents are missing. The good software documentation process helps the programmer working on software to understand its features and functions. The software documentation process is specific, where it provides all the information important to the person who works on the software at different levels of abstraction. The documentation process aims to translate source code of the software system into a set of documents (i.e., graphs). In reality, several software systems have little to no software documentation, especially the legacy software. Many companies are facing some problems with legacy systems such as: software understanding and software maintenance. The reason behind these problems is the absence of software documentation. Software systems that are not documented hard to be changed [41]. Common examples of such documentation include requirement and specification documents [22]. Vsound provides as output a set of documents describe the source code and its dependencies.

Software visualization is the graphical show of information about the software source code. Software visualization is not a simple process since the amount of information to be included in the graph is may be far bigger than can be displayed. The software visualization tool presents information about the software source code at different levels of abstraction. The visualization tool focuses on displaying different aspects of the source code. It should provide a way to choose and display just particular information based on the software source code. Usually, the visualization process must find out the level of abstraction of the information it presents about the software source code. The software visualization tool must convert the software source code into a graph. It also must able to visualize a huge amount of information regarding the software source code.
code. Moreover, the visualization tool must provide an easy
way for navigation [24].

Vsound relies on the source code of software systems to
extract a set of documents describing the software. The
software source code is the most important resource of
information when the software documentation is missing. In
order to document existing OO software based on its source
code there is a need to extract the main source code elements
and dependencies between those elements. Vsound considers
that the software implementation consists of OO source code
elements and the code dependencies. The main elements of OO
source code include: package, class, attribute and method.
Vsound also focuses on the method body. The method body
consists of a method signature, which represents the access
level, returned data type and parameter list (i.e., name, data
type and order). It also consists of the body of the method (i.e.,
local variable, method invocation and attribute access). Vsound
focuses on the main dependencies between source code
elements such as: inheritance, attribute access and method
invocation in the documentation process. Inheritance relation
occurs when a general class (i.e., superclass) is connected to its
specialized classes (i.e., subclasses). Method invocation
relation occurs when methods of one class use methods of
another class. While, attribute access relation occurs when
methods of one class use attributes of another class.

### III. APPROACH OVERVIEW

This section provides the main concepts and hypotheses
used in the Vsound approach. It also gives an overview of the
software documentation process. Then, it presents the OO
source code model. Finally, it shortly describes the example
that illustrates the remaining of the paper.

#### A. Key Ideas

The general objective of Vsound approach is to document
the source code of a single software system based on the static
analysis of its source code. Mining the main entities of the
source code in addition to the source code dependencies is a
first necessary step towards this objective. Vsound considers
software systems in which software functionalities are
implemented at the programming language level (i.e., source
code). Vsound also restricts to OO software system. Thus,
software functionalities are implemented using OO source code
elements such as packages, classes, attributes, methods or
method body elements (i.e., local variable, attribute access,
method invocation). There are several ways to document the
software source code such as generate a descriptive comments
that summarize all software classes or methods [12]. Vsound
aims to document the software source code as a set of
documents (i.e., graphs). The software documentation process
via single graph is difficult. Thus, there is a need to document
the software source code through several documents with
details.

The documentation process must cover all granularity
levels of the software source code (i.e., package, class, attribute
and method). Vsound focuses on the extracting of three types
of documents (i.e., graphs). The first document contains
general information about the software source code. This

document called the package document. It represents all
software packages in addition to the number of classes per
package. It also provides quantitative information about a
software system. The second document contains information
about software classes. This document called the class
document. It represents all information about the class, such as
the number of attributes and methods in addition to class
dependencies. The third document contains information about
software methods. This document called the method document.
It represents all information about the method, such as the
number of parameters and local variables in addition to method
dependencies like attribute access and method invocation.

#### B. The OO Software Documentation Process

Vsound goal is to document the OO software by using the
source code of this software. The software documentation
process takes the software's source code as its inputs and
generates a set of documents as its outputs.

<figure><img src="image_2.png" /><figcaption>Figure 1. The OO software documentation process.</figcaption></figure>

Vsound approach exploits the main source code elements
and the dependencies between those elements in order to
document and understand existing software system. Figure 1
shows the software documentation process. The first step of
this process aims at extracting the main OO source code
elements (i.e., package, class, attribute, method) and their
relationships (i.e., inheritance, method invocation and attribute
access) based on the static analysis of source code. In the
second step, Vsound approach relies on the mined source code
to document software at package level. In the third step,
Vsound approach documents the software at class level based
on the extracted source code. The last step of this process aims
at documenting the software at method level. Finally, these
documents (i.e., graphs) are used to understand and document
the software system.

#### C. Object-oriented Source Code Model

The Vsound source code meta-model was inspired by the
FAMIX [39] information exchange meta-model. The source
code meta-model (cf. Figure 2) displays the main source code
elements and their relations. Mainly, the reader gets enough
information if he considers the main type entities that construct
an object-oriented system. These are package, class, interface,
attribute, method, and the relations between them, such as
inheritance, access and invocation. The OO source code model
shows structural source code entities such as: packages, classes
and methods. In addition, this model represents explicitly
information such as: a class inherits from another class (i.e., inheritance), a method accesses attributes (i.e., access) and a method invokes other methods (i.e., invocation). These abstractions are very important and needed for reengineering tasks such as: dependency analysis [40].

<figure><img src="image_3.png" /><figcaption>Figure 2. The source code meta-model [39].</figcaption></figure>

### D. An Illustrative Example

As an illustrative example, this paper considers the drawing shapes software<fnref n="3" /> (cf. Figure 3). This software allows a user to draw three different kinds of shapes. The drawing shapes software allows user to draw lines, rectangles and ovals and choose the color of the drawn shape (cf. Figure 3). This example used to better explain some parts of this paper. However, Vsound approach only uses the source code of software as input of the documentation process and thus do not know the code dependencies or software metrics in advance.

<figure><img src="image_4.png" /><figcaption>Figure 3. The drawing shapes software.</figcaption></figure>

## IV. THE OBJECT-ORIENTED SOFTWARE DOCUMENTATION PROCESS STEP BY STEP

This section describes the OO software documentation process step by step. According to Vsound, the approach identifies the software documentation in four steps as detailed in the following.

### A. Extracting the Source Code of Software via Static Code Analysis

Static code analysis is the analysis of computer software that is performed without actually executing programs built from that software [4]. While, analyzing the actions performed by a program while it is being executed is called dynamic analysis [5]. Vsound approach accepts as input the source code of software. Then, the proposed approach generates an XML file based on the static code analysis<fnref n="4" />. The mined XML file contains structural information between OO source code elements (e.g., draw method is inside the MyLine class). It also contains structural dependencies between source code elements (e.g., inheritance, attribute access and method invocation). The Eclipse Java Development Tools (JDT) and the Eclipse Abstract Syntax Tree (AST) can be used to access, modify and read the elements of a Java program [37]. ASTs are broadly used in several fields of software engineering. AST is used as a representation of source code [25]. The extracted XML file contains all information needed to document the software by visualizing its code as a set of graphs. Figure 4 shows the mined XML file from the source code of drawing shapes software.

<figure><img src="image_5.png" /><figcaption>Figure 4. The extracted XML file of drawing shapes software.</figcaption></figure>

### B. Identifying the Package Document

Vsound approach extracts several documents based on the software source code. These documents cover all granularity levels of the source code. To provide a better understanding of existing software, it is impossible to gather all information in one graph. Vsound approach provides one document (i.e., graph) for every granularity level (i.e., package, class, attribute, method). The package document aims to provide specific information about software. The package document contains

<footnote n="3">³ Source code: http://code.google.com/p/drawing-shapes-software/</footnote>

<footnote n="4">⁴ Source code: https://code.google.com/p/abstract-syntax-tree-vsound/</footnote>
information about software packages and quantitative information about the software (cf. Figure 5).

Figure 5 shows the mined package document from drawing shapes software. This document provides information about software packages. As an example, from the graph in Figure 5, drawing shapes software consists of two packages, each one contains three classes. In addition, this document provides information about software metrics such as Lines of Code (LoC), Number of Packages (NoP), Number of Classes (NoC), Number of Attributes (NoA) and Number of Methods (NoM). As an example, from the graph in Figure 5, drawing shapes software consists of 29 methods and 14 attributes.

In order to understand the software source code, the package document is very useful. The goal of this document is to give a general view about software system and present the size of the software (i.e., large, medium or small system). Vsound approach applies to different sizes of software systems. The different complexity levels show the scalability of Vsound approach to dealing with such systems.

<figure><img src="image_6.png" /><figcaption>Figure 5. The package document mined from drawing shapes software.</figcaption></figure>

### C. Identifying the Class Document

The class document displays information about software classes. This information is very helpful toward understanding the software. Vsound approach identifies three documents belong to the class document category. The first document represents the class information document (cf. Figure 6). This document shows the number of classes per package. It also presents information about each class in the package. The class information document consists of the class name, super class name, is an interface, super interface name, number of attributes and number of methods. As an example, the class MyShape in Figure 6 consists of five attributes and 12 methods.

<figure><img src="image_7.png" /><figcaption>Figure 6. Part of the class information document mined from drawing shapes software.</figcaption></figure>

The second document represents the class dependency document (cf. Figure 7). This document shows the main relations between software classes (i.e., Inheritance relation). As an example, the classes MyLine, MyOval and MyRectangle in Figure 7 have a super class called MyShape.

<figure><img src="image_8.png" /><figcaption>Figure 7. The class dependency document mined from drawing shapes software.</figcaption></figure>

<figure><img src="image_9.png" /><figcaption>Figure 8. Part of the class content document mined from drawing shapes software.</figcaption></figure>

The third document represents the class content document (cf. Figure 8). This document shows the main content of each class. It also shows the size of class, where the height of class can considered as an indicator of class size. Vsound considers the main elements in the classes. The class content document includes the attribute name and its data type in addition to the
method name and its returned data type. As an example, the class PaintJPanel contains currentShape attribute of MyShape type. It also contains setCurrentShapeType method.

## D. Identifying the Method Document

The method document shows information about software methods. This information is very useful toward understanding the software system. Vsound approach identifies three documents belong to the method document category. The first document represents the method information document (cf. Figure 9). This document provides information about software methods. The method information document contains the following information: the name of a method, the method returned data type, is a static method, number of parameters and the parameter list (i.e., name, data type and order). As an example, the method MyRectangle in Figure 9 consists of 5 parameters.

The second document represents the method content document (cf. Figure 10). This document shows the main content of each method. It also shows the size of method, where the height of method can considered as an indicator of method size. Vsound considers the main elements in the method body. The method content document includes the local variable name and its data type, attribute access name and its type and method invocation name and the declared class. As an example, method PaintJPanel in Figure 10 contains addMouseListener which is a method invocation.

<figure><img src="image_10.png" /><figcaption>Figure 9. Part of the method information document mined from drawing shapes software.</figcaption></figure>

The third document represents the method dependency document (cf. Figure 11). This document shows the main relations between software methods (i.e., method invocation and attribute access). As an example, the method "draw" that is declared in MyShape class is invoked by the paintComponent method in PaintJPanel class. Also, the currentShape attribute that declared at DrawingShapes class is accessed in paintJPanelMouseDragged method that declared at PaintJPanel class.

<figure><img src="image_11.png" /><figcaption>Figure 10. Part of the method content document mined from drawing shapes software.</figcaption></figure>

<figure><img src="image_12.png" /><figcaption>Figure 11. Part of the method dependency document mined from drawing shapes software.</figcaption></figure>

## V. EXPERIMENTATION

This section presents the experiment that conducted to validate the Vsound approach. Firstly, this section presents the ArgoUML case study. Next, it presents the evaluation metrics. Then, it also presents detail the architecture and functioning of the Vsound prototype tool and, at last, it presents the software documentation results and threats to validity of Vsound approach.
## A. Case Study

In addition to the toy drawing shapes example used in this paper, Vsound approach has been tested on other software called ArgoUML. ArgoUML is a widely used open source tool for UML modeling tool. ArgoUML supports the following UML 1.4 diagram types: class diagram, state chart diagram, activity diagram, use case diagram, collaboration diagram, deployment diagram and sequence diagram. The advantage of using the ArgoUML as a case study is that ArgoUML software well documented. In this evaluation, the results are based on the source code of the software that is freely available for downloading in the case study website<fnref n="5" />. ArgoUML runs on any Java platform and is available in ten languages. ArgoUML software is presented in Table 1 characterized by metrics LoC, NoP, NoC, NoA and NoM.

<table><caption>TABLE I. SIZE METRICS FOR ARGOUML SOFTWARE SYSTEM.</caption><thead><tr><td>Software</td><td>LoC</td><td>NoP</td><td>NoC</td><td>NoA</td><td>NoM</td></tr></thead><tbody><tr><td>ArgoUML</td><td>120,348</td><td>81</td><td>1,666</td><td>3977</td><td>14904</td></tr></tbody></table>

## B. Evaluation Measures

In order to evaluate Vsound approach, precision and recall measures are used. In this paper, the precision is the percentage of correctly retrieved links to the total number of retrieved links. The recall is the percentage of correctly retrieved links to the total number of relevant links [36]. In this work, link means: source code element (package, class, attribute, method or local variable) or dependency (inheritance, method invocation or attribute access). All measures (i.e., precision and recall) have values in [0, 1]. If precision is equal to one, every one of retrieved links is relevant. However, relevant links might not be retrieved. If recall is equal to one, all relevant links are retrieved. Nevertheless, some retrieved links might not be relevant. For example, by considering software system contains 95 relations (i.e., inheritance relation). After applying the proposed approach on this software, the result shows that 90 relations are identified correctly (i.e., all retrieved links are relevant). However, five relations are missing. In this case, precision is equal to 1 (i.e., 90/90=1) and recall is equal to 0.94 (i.e., 90/95=0.94).

## C. A Simplified Structural View of the Architecture of Vsound

The developed prototype tool<fnref n="6" /> of Vsound approach implements the proposed software documentation process. Figure 10 provides an overview of the Vsound tool architecture. It receives as input the software source code and produces as output a set of documents. The XML_Generator module of Vsound produces an XML document which represents the software source code elements and the dependencies between those elements. The tool then starts to generate the software documents by using the DOT_File_Builder component. These documents are serialized as DOT files. DOT is a plain text graph description language. Starting from these DOT files, the tool builds the software

document (i.e., graph). For doing so, the Vsound[GUI component of Vsound uses an external library, called Graphviz<fnref n="7" /> to produce SVG files containing the documentation of each software artefact (i.e., package, class and method). SVG (Scalable Vector Graphics) is an XML-based file format for describing vector graphics [28].

<figure><img src="image_13.png" /><figcaption>Figure 12. A simplified structural view of the architecture of Vsound.</figcaption></figure>

## D. Result

Vsound approach has tested on the ArgoUML case study and obtained promising results. The preliminary evaluation of Vsound shows the significance of this approach. Vsound approach extracted a collection of documents from the source code of ArgoUML software. The first document represents the package document which represents general information about ArgoUML such as: number of packages, number of classes per each package and quantitative information about ArgoUML like LoC and NoM. The second document represents the class document (i.e., the class information document, the class dependency document and the class content document). The identified documents by Vsound provide useful information about software classes. The third document represents the method document (i.e., the method information document, the method content document and the method dependency document). This document shows meaningful information about the software methods. Results show that precision appears to be high for all mined documents from ArgoUML software. This means that all mined documents grouped as software documentation are relevant. Considering the recall metric, recall is also quite high. This means that most source code elements and their dependencies that compose software documentation are mined. Thanks to Vsound approach that identifies software documentation in a novel way.

<footnote n="5">⁵ArgoUML: http://argouml.tigris.org/</footnote>

<footnote n="6">⁶Vsound source code: https://code.google.com/p/fidd/issues/detail?id=2</footnote>

<footnote n="7">⁷http://www.graphviz.org/</footnote>
## E. Threats to Validity

Vsound approach considers only the Java software systems. This represents a threat to prototype validity that limits Vsound implementation ability to deal only with software systems that are developed based on the Java language. Vsound assumes that source code elements and the dependencies between those elements can be determined statically, such as ArgoUML used in Vsound evaluation. Nevertheless, there exist systems that only behave differently depending on runtime parameters. For such systems, there is a need to extend Vsound to include dynamic analysis techniques. Vsound approach assumes that software documentation can be determined graphically as a set of documents based on the source code. In some cases, there is a need to document software systems by describing their functionalities. This means that Vsound maybe not reliable (or should be improved with other techniques) in all cases to identify software documentation. Documenting software using the names of source code elements and dependencies in its implementation is not always reliable. Thus, it is important to use the comments (i.e., line and block comment) in the source code in order to enhance the documentation process.

## VI. RELATED WORK

This section presents the related work relevant to Vsound contribution. It also provides a concise overview of the different approaches and shows the need to propose Vsound approach.

Wettel et al., [11] proposed an approach to visualize object oriented software as a city to solve the navigation problem. CodeCity is a visualization tool that represents the software with a city metaphor. The classes are represented as buildings and the packages as districts. Moreover, some of the visual properties (i.e., width, height, position, and color) of the city artifacts carry information about the software element they represent (e.g., the height of the building represents the number of methods). Their approach does not consider dependencies between source code elements.

Hammad et al., [32] used software visualization techniques to visualize class coupling based on analyzing the source code statically. Other works such as [33] and [34] applied software visualization to model the dynamic behavior of the software by instrumenting the source code in order to monitor the program executions. Moreover, visualization techniques can be applied on software documentation to make it easier and more helpful. For example, work in [35] proposed a visualization framework to visualize bug reports that are saved in software repositories. The proposed framework visualized the status changing for selected bugs, as well as, bug-developer relations by using different shapes and colors.

Al-msie'deen et al., [6] [9] [29] [30] proposed an approach called REVPLINE to identify and document features from the object-oriented source code of a collection of software product variants. The authors presented a new way to document the mined feature implementations in [19]. The proposed approach gives as output for each feature implementation, a name and description based on the use-case name and description [7] [8]. REVPLINE approach aims to document the extracted features from a collection of software variants, while Vsound aims to

document OO software as a set of graphs. Hammad et al., [31] presented an approach that focuses on analyzing code changes to automatically detect any OO constraints violation without using graphs as in Vsound approach.

Graham et al., [26] used a solar system metaphor to represent the software source code. The main code entities (i.e., packages and classes) are represented as planets encoding software metrics in the planets' size and color. This visualization represents the software as a virtual galaxy consists of many solar systems. Each solar system represents a package. The central star of each solar system represents the package itself, while the planets, in orbit around it, represent classes within the package. For planets, the blue planets represent classes while the light blue planets represent interfaces. Solar systems are shown as a circular formation. The Solar System metaphor represents packages and classes of software without considering methods and their body. In addition, it focuses only on the inheritance relation between classes without considering the attribute access and method invocation relations.

McBurney and McMillan [12] create summaries of Java methods by using local information (i.e., keywords in the method) and contextual information (i.e., keywords in the most important referenced methods). The method's summaries are generated from elements in the method's signature and body. The approach applied only to the method without considering other artifacts (e.g., package and class). The proposed approach used natural language processing and information retrieval techniques. The type of summary classified under abstract Summary.

Haiduc et al., [27] proposed an approach for summarizing the software source code. The source code summaries consider only the software methods and classes. The proposed approach used information retrieval techniques such as latent semantic indexing and vector space model. The approach extracts the text from the source code of the software and converts it into a corpus (i.e., source code corpus creation). Then, the approach determines the most relevant terms for documents in the corpus and includes them in the summary (i.e., generating source code summaries using text retrieval). Their approach does not exploit structural information from the source code.

## VII. CONCLUSIONS AND FUTURE WORK

This paper proposed a new approach for documenting and understanding the software system. The novelty of this approach is that it exploits code dependencies and quantitative information in source code to document OO software in an efficient way by means of a set of documents. The Vsound approach has implemented and evaluated its results on several case studies. The results of this evaluation showed that most of the software systems were documented correctly. Regarding future work, Vsound approach plans to automatically generate descriptive comments that summarize all software packages, classes and methods. It also plans to use the line and block comments in the documentation process.
REFERENCES

[1] V. Rajlich and N. Wilde, "The role of concepts in program comprehension," in Proceedings of the 10th International Workshop on Program Comprehension, ser. IWPC '02. Washington, DC, USA: IEEE Computer Society, 2002, pp. 271-275.

[2] S. Diehl, Software Visualization - Visualizing the Structure, Behaviour, and Evolution of Software. Springer, 2007.

[3] P. Caserta and O. Zendra, "Visualization of the static aspects of software: A survey," IEEE Trans. Vis. Comput. Graph., vol. 17, no. 7, pp. 913-933, 2011.

[4] Y. Smaragdakis and C. Csallner, "Combining static and dynamic reasoning for bug detection," in Tests and Proofs, First International Conference, TAP 2007, Zurich, Switzerland, February 12-13, 2007. Revised Papers, 2007, pp. 1-16.

[5] M. Egele, T. Scholte, E. Kirda, and C. Kruegel, "A survey on automated dynamic malware-analysis techniques and tools," ACM Comput. Surv., vol. 44, no. 2, p. 6, 2012.

[6] R. Al-Msie'deen, A. Seriai, M. Huchard, C. Urtado, and S. Vauttier, "Mining features from the object-oriented source code of software variants by combining lexical and structural similarity," in IEEE 14th International Conference on Information Reuse & Integration, IRI 2013, San Francisco, CA, USA, August 14-16, 2013, 2013, pp. 586-593.

[7] R. Al-Msie'deen, A. Seriai, M. Huchard, C. Urtado, and S. Vauttier, "Documenting the mined feature implementations from the object-oriented source code of a collection of software product variants," in The 26th International Conference on Software Engineering and Knowledge Engineering, Hyatt Regency, Vancouver, BC, Canada, July 1-3, 2013., 2014, pp. 138-143.

[8] R. Al-Msie'deen, M. Huchard, A. Seriai, C. Urtado, and S. Vauttier, "Automatic documentation of [mined] feature implementations from source code elements and use-case diagrams with the REVPLINE approach," International Journal of Software Engineering and Knowledge Engineering, vol. 24, no. 10, pp. 1413-1438, 2014.

[9] R. Al-Msie'deen, M. Huchard, A. Seriai, C. Urtado, and S. Vauttier, "Reverse engineering feature models from software configurations using formal concept analysis," in Proceedings of the Eleventh International Conference on Concept Lattices and Their Applications, Ko'sice, Slovakia, October 7-10, 2014., 2014, pp. 95-106.

[10] S. Haiduc, J. Aponte, and A. Marcus, "Supporting program comprehension with source code summarization," in Proceedings of the 32Nd ACM/IEEE International Conference on Software Engineering - Volume 2, ser. ICSE '10. New York, NY, USA: ACM, 2010, pp. 223-226.

[11] R. Wettel, M. Lanza, and R. Robbes, "Software systems as cities: A controlled experiment," in Proceedings of the 33rd International Conference on Software Engineering, ser. ICSE '11. New York, NY, USA: ACM, 2011, pp. 551-560.

[12] P. W. McBurney and C. McMillan, "Automatic documentation generation via source code summarization of method context," in Proceedings of the 22Nd International Conference on Program Comprehension, ser. ICPC 2014. New York, NY, USA: ACM, 2014, pp. 279-290.

[13] J. T. Stasko, M. H. Brown, and B. A. Price, Eds., Software Visualization. Cambridge, MA, USA: MIT Press, 1997.

[14] H. A. M'uller, S. R. Tilley, and K. Wong, "Understanding software systems using reverse engineering technology perspectives from the rigi project," in Proceedings of the 1993 Conference of the Centre for Advanced Studies on Collaborative Research, October 24-28, 1993, Toronto, Ontario, Canada, 2 Volumes, 1993, pp. 217-226.

[15] K. H. Bennett and V. T. Rajlich, "Software maintenance and evolution: A roadmap," in Proceedings of the Conference on The Future of Software Engineering, ser. ICSE '00. New York, NY, USA: ACM, 2000, pp. 73-87.

[16] E. J. Chikofsky and J. H. Cross II, "Reverse engineering and design recovery: A taxonomy," IEEE Softw., vol. 7, no. 1, pp. 13-17, Jan. 1990.

[17] N. Pereira, M. J. V. Pereira, and P. R. Henriques, "Comment-based concept location over system dependency graphs," in 3rd Symposium on Languages, Applications and Technologies, SLATE 2014, June 19-20, 2014 - Bragancá, Portugal, 2014, pp. 51-58.

[18] C. W. Krueger, "Software reuse," ACM Comput. Surv., vol. 24, no. 2, pp. 131-183, Jun. 1992.

[19] R. Al-Msie'Deen, "Reverse engineering feature models from software variants to build software product lines: REVPLINE approach," Theses, Université Montpellier II - Sciences et Techniques du Languedoc, Jun. 2014.

[20] N. H. Madhavji, J. Fernandez-Ramil, and D. Perry, Software Evolution and Feedback: Theory and Practice. John Wiley & Sons, 2006.

[21] S. A. Bohner, "Impact analysis in the software change process: a year 2000 perspective," in 1996 International Conference on Software Maintenance (ICSM '96), 4-8 November 1996, Monterey, CA, USA, Proceedings, 1996, pp. 42-51.

[22] A. Forward and T. C. Lethbridge, "The relevance of software documentation, tools and technologies: A survey," in Proceedings of the 2002 ACM Symposium on Document Engineering, ser. DocEng '02. New York, NY, USA: ACM, 2002, pp. 26-33.

[23] R. Koschke, "Software visualization in software maintenance, reverse engineering, and re-engineering: A research survey," Journal of Software Maintenance, vol. 15, no. 2, pp. 87-109, Mar. 2003.

[24] J. I. Maletic, A. Marcus, G. Dunlap, and J. Leigh, "Visualizing object-oriented software in virtual reality," in 9th International Workshop on Program Comprehension (IWPC 2001), 12-13 May 2001, Toronto, Canada, 2001, pp. 26-35.

[25] G. Rakic and Z. Budimac, "Introducing enriched concrete syntax trees," CoRR, vol. abs/1310.0802, 2013.

[26] H. Graham, H. Y. Yang, and R. Berrigan, "A solar system metaphor for 3d visualisation of object oriented software metrics," in Australasian Symposium on Information Visualisation, InVis.au, Christchurch, New Zealand, 23-24 January 2004, 2004, pp. 53-59.

[27] S. Haiduc, J. Aponte, L. Moreno, and A. Marcus, "On the use of automated text summarization techniques for summarizing source code," in 17th Working Conference on Reverse Engineering, WCRE 2010, 13-16 October 2010, Beverly, MA, USA, 2010, pp. 35-44.

[28] N. A. Aboud, G. Arévalo, J. Falleri, M. Huchard, C. Tibermacine, C. Urtado, and S. Vauttier, "Automated architectural component classification using concept lattices," in Joint Working IEEE/IFIP Conference on Software Architecture 2009 and European Conference on Software Architecture 2009, WICSA/ECSA 2009, Cambridge, UK, 14-17 September 2009, 2009, pp. 21-30.

[29] R. Al-Msie'deen, A. Seriai, M. Huchard, C. Urtado, S. Vauttier, and H. E. Salman, "Mining features from the object-oriented source code of a collection of software variants using formal concept analysis and latent semantic indexing," in The 25th International Conference on Software Engineering and Knowledge Engineering, Boston, MA, USA, June 27-29, 2013., 2013, pp. 244-249.

[30] R. Al-Msie'deen, A. Seriai, M. Huchard, C. Urtado, S. Vauttier, and H. E. Salman, "Feature location in a collection of software product variants using formal concept analysis," in Safe and Secure Software Reuse - 13th International Conference on Software Reuse, ICSR 2013, Pisa, Italy, June 18-20. Proceedings, ser. Lecture Notes in Computer Science, J. M. Favaro and M. Morisio, Eds., vol. 7925. Springer, 2013, pp. 302-307.

[31] M. Hammad, M. Hammad, and M. Bsoul, "An approach to automatically enforce object-oriented constraints," International Journal of Computer Applications in Technology, vol. 49, no. 1, pp. 50-59, 2014.

[32] M. Hammad and A. Rawashdeh, "A framework to measure and visualize class coupling," International Journal of Software Engineering and Its Applications, vol. 8, no. 4, pp. 137-146, 2014.

[33] M. Hammad and J. Cook, "Lightweight deployable software monitoring for sensor networks," in The 18th International Conference on Computer Communications and Networks, San Francisco, California, August 3-6, 2009., 2009, pp. 1-6.
[34] M. Hammad and J. Cook, "Lightweight monitoring of sensor software," in The 2009 ACM Symposium on Applied Computing, Honolulu, Hawaii, USA, March 9-12, 2009., 2009, pp. 2180-2185.

[35] M. Hammad, S. Abufakher, and M. Hammad, "Visualization approach for bug reports in software systems," International Journal of Software Engineering and Its Applications, vol. 8, no. 10, pp. 37–46, 2014.

[36] T. F. Bissyandé, F. Thung, S. Wang, D. Lo, L. Jiang, and L. Réveillère, "Empirical evaluation of bug linking," in The 17th European Conference on Software Maintenance and Reengineering, Genova, Italy, March 5-8, 2013., 2013, pp. 89–98.

[37] J. L. Overbey, "Immutable source-mapped abstract syntax tree: a design pattern for refactoring engine APIs," in The 20th Conference on Pattern Languages of Programs, Monticello, Illinois, 2013, pp. 1–8.

[38] J. S. Poulin, J. M. Caruso, and D. R. Hancock, "The business case for software reuse," IBM Systems Journal, vol. 32, no. 4, pp. 567–594, 1993.

[39] S. Tichelaar, S. Ducasse, and S. Demeyer, "FAMIX: Exchange experiences with CDIF and XMI," in The ICSE 2000 Workshop on Standard Exchange Format, WoSEF 2000, 2000, pp. 1–7.

[40] S. Tichelaar, S. Ducasse, S. Demeyer, and O. Niestrasz, "A meta-model for language-independent refactoring," in The International Symposium on Principles of Software Evolution, 2000, pp. 157–167.

[41] A. Al-Shamailh, R. AL-msie'deen, and A. Alsarhan, "Comparison between the rules of data storage tools," International Journal of Database Theory and Application, vol. 8, no. 1, pp. 129–136, 2015.

AUTHORS PROFILE

Ra'Fat Al-Msie'Deen is a lecturer at the Information Technology department in Mu'tah University, Al Karak - Jordan. He received his PhD. in Computer Science from University of Montpellier 2, France in 2014. He received his Masters degree in Information Technology from University Utara Malaysia, Malaysia in 2009. He got his B.Sc. in Computer Science from Al - Hussein Bin Talal University, Jordan in 2007. His research interest is software engineering with focusing on software documentation, software visualization, software maintenance, software evolution, reverse engineering, reuse, re-engineering, software product line and formal concept analysis.