ScaMaha: A Tool for Parsing, Analyzing, and Visualizing Object-Oriented Software Systems

International Journal of Computing and Digital Systems
2025, VOL. 17, NO.1, 1-20
http://dx.doi.org/10.12785/ijcds/1571046420
ScaMaha: A Tool for Parsing, Analyzing, and Visualizing
Object-Oriented Software Systems
Ra’Fat Al-Msie’deen1
1
Department of Software Engineering, Faculty of IT, Mutah University, Mutah 61710, Karak, Jordan
Received 3 July 2024, Revised 5 January 2025, Accepted 9 January 2025
Abstract: Reverse engineering tools are required to handle the complexity of software products and the unique requirements of many
different tasks, like software analysis and visualization. Thus, reverse engineering tools should adapt to a variety of cases. Static Code
Analysis (SCA) is a technique for analyzing and exploring software source code without running it. Manual review of software source
code puts additional effort on software developers and is a tedious, error-prone, and costly job. This paper proposes an original approach
(called ScaMaha) for Object-Oriented (OO) source code analysis and visualization based on SCA. ScaMaha is a modular, flexible,
and extensible reverse engineering tool. ScaMaha revolves around a new meta-model and a new code parser, analyzer, and visualizer.
ScaMaha parser extracts software source code based on the Abstract Syntax Tree (AST) and stores this code as a code file. The code
file includes all software code identifiers, relations, and structural information. ScaMaha analyzer studies and exploits the code files to
generate useful information regarding software source code. The software metrics file gives unique metrics regarding software systems,
such as the number of method access relations. Software source code visualization plays an important role in software comprehension.
Thus, ScaMaha visualizer exploits code files to visualize different aspects of software source code. The visualizer generates unique
graphs about software source code, like the visualization of inheritance relations. ScaMaha tool was applied to several case studies
from small to large software systems, such as drawing shapes, mobile photo, health watcher, rhino, and ArgoUML. Results show the
scalability, performance, soundness, and accuracy of ScaMaha tool. Evaluation metrics, such as precision and recall, demonstrate the
accuracy of ScaMaha in parsing, analyzing, and visualizing software source code, as all code artifacts — including code files, software
metrics files, and code visualizations — were correctly extracted.
Keywords: Software engineering, Reverse engineering, Software re-engineering, Object-Oriented source code, Static code analysis,
Software visualization, Software metrics, ScaMaha tool.
1. INTRODUCTION
Reverse engineering tools are necessary to cope with
the complexity of software systems. Also, such tools should
cope with the specific requirements of the various reverse
engineering tasks, like software comprehension and visual-
ization. Thus, these tools should adapt to a wide range of
cases [1]. To analyze software code, tools need to represent
it. Such a representation should be comprehensive. Software
comprehension is still a manual activity. Thus, advanced
tools will help developers fully understand complex systems
[2]. This paper presents ScaMaha tool, which is a reverse
engineering tool for performing software analysis and vi-
sualization. The core of ScaMaha tool revolves around the
meta-model, code parser, code analyzer, and code visualizer.
With ScaMaha, tool developers can analyze and visualize
software code. Also, developers can develop new, specific,
and dedicated reverse engineering tools based on the infras-
tructure of ScaMaha tool (cf. Figure 1).
Software has become an integral part of modern life,
permeating nearly every domain, including smart cities,
education, healthcare, robotics, and gaming [3], [4]. In
smart cities, software enables the seamless integration of
infrastructure, services, and data [5]. In education and
healthcare, it supports learning systems, patient manage-
ment, and innovative solutions [6]. In robotics, software
drives automation and intelligent task execution, while in
gaming, it powers immersive experiences with realistic
graphics and AI-driven gameplay. However, the growing
complexity of software systems, combined with incomplete
documentation and the need to maintain and evolve legacy
systems, poses significant challenges for developers. To
address these issues, developers rely on advanced tools
to manage complexity and to understand, analyze, and
visualize legacy code. These tools are essential for ensuring
the efficiency and sustainability of software solutions across
diverse sectors.
E-mail address: rafatalmsiedeen@mutah.edu.jo

2 Ra’Fat Al-Msie’deen
Figure 1. Typical infrastructure for re-engineering tools.
SCA techniques analyze software products by exam-
ining their source code without executing them. These
techniques improve software quality by identifying potential
code faults or vulnerabilities in the early stages of software
development [7]. SCA is a software verification method
aimed at capturing faults in software code early to avoid
costly repairs later [8]. Nowadays, SCA is broadly used, and
several tools are freely available for different programming
languages, such as Java, C++, and others. SCA is the
method of exploring software code without running it
to find the main code elements (e.g., class and method
names) and their relations (e.g., inheritance and method
invocation) [9], [10]. In contrast, dynamic code analysis
involves running the software code and observing how it
behaves and performs while it runs [11].
In this work, the subject of study is the source code
of OO software systems. More precisely, the author is
interested in parsing, analyzing, and visualizing software
source code. Software Engineering is the systematic way to
build and maintain software systems [12]. Software source
code is considered as one of the important resources from
which software system is built [13]. Moreover, reverse
engineering aims at analyzing legacy software systems to
retrieve their design and other information based on their
software source code [14].
The main challenge in evolving and maintaining legacy
software products is comprehending the chosen software.
Reverse engineering is the process of studying and an-
alyzing software products [15]. The goal of this process
is to identify the product’s components and their relation-
ships. Furthermore, this process aims at creating several
representations of the software product in another shape
or at a different level of abstraction. The main goal of the
software re-engineering process is to improve or modify
current software so it can be comprehended, administered,
and used again as new software [16], [17].
Software source code analysis presents significant in-
formation for the re-engineering and reverse engineering
activities of software products. It assists software engineers
in software evolution, maintenance, visualization, reuse, and
understanding [18]. It is anticipated that the volume of
software systems in 2025 will exceed 1 trillion Lines of
Code (LOC), which shows the value of code analysis in
the future [19]. The source code of any software can be
analyzed through numerous methods. For instance, software
code may be analyzed using static or dynamic methods [20],
[21]. Also, the software code can be analyzed with a hybrid
method that combines static and dynamic methods.
Parsing software source code in order to analyze it is
a central activity of many software engineering tasks such
as feature location, code summarization, and visualization.
Thus, software source code parsing is one of the main soft-
ware engineering activities. Code parsing is required when a
software engineer maintains, visualizes, documents, reuses,
migrates, or enhances software systems. When a software
developer deals with structural representations of software

International Journal of Computing and Digital Systems 3
code, such as in the form of an AST, the process of data pre-
processing becomes quite sophisticated and necessitates the
use of code parsers (or code analysis tools). An important
method of expressing the structure information of software
code is AST [22].
Figure 1 illustrates the typical organization of a re-
engineering environment. The left side of Figure 1 displays
the software source code, which can be brought into this
environment using suitable code parsers, such as ScaMaha
parser. Also, Figure 1 displays the main repository of this
environment, which holds the software code (aka. code
database). The repository includes an abstracted model of
the software code, which is based on ScaMaha’s meta-
model. The right side of Figure 1 displays the tools
(e.g., ScaMaha analyzer and visualizer) that utilize the
repository as their information source to perform specific
tasks. The key part that makes all tools work together is
the repository’s meta-model.
To support software comprehension, visualization, and
maintenance, meta-models are often employed during soft-
ware reverse engineering tasks to describe the components
of software and their relationships. Reverse engineering
tools frequently define their own meta-models depending
on the intended goals and functionalities [23].
Each programming language (e.g., Java) has its own
rigorous syntax that can be thought of as a collection of
predetermined rules revealing all probable programming
language constructions. Analyzing the raw software code
with these predefined rules allows depicting it in the shape
of a parse tree and, after that, as an AST [24]. By dealing
with this structure, scholars enhance their findings for
several software engineering duties, such as code visual-
ization and comprehension [25]. In software engineering
domain, tools are typically based on several tools executing
particular tasks, such as mining code identifiers, performing
code analysis, and visualizing code [26]. Thus, a common
code meta-model (cf. Figure 1) is required to represent in-
formation or facts about the software that is being analyzed
[27].
This study presents ScaMaha tool, which parses, an-
alyzes, and visualizes OO source code. ScaMaha parser
generates an XML file (called a code file) representing
software code (cf. Listing 1). Software developers can use
this code parser in any work that deals with software code,
such as feature identification [28], [29], [30] and software
evolution [31]. ScaMaha tool extracts all code identifiers
and relations.
In addition to code parser, this study presents ScaMaha
analyzer. This analyzer accepts as input the software code
file that was produced by ScaMaha parser to generate a
software metrics file (an XML file). The software metrics
file contains quantitative information regarding software
source code, like the number of software classes and
methods. Software engineers can use or extend the current
version of ScaMaha analyzer to examine other aspects of
software code. The novelty of this analyzer is that it exploits
code information to uniquely identify some features of
software code, such as the number of method invocations
and attribute accesses. ScaMaha analyzer can be used in
several software engineering research areas, such as soft-
ware maintenance.
In addition to a code parser and analyzer, ScaMaha
also presents a code visualizer. This visualizer accepts
as input the code file generated via ScaMaha parser and
produces a set of code graphs. Each graph addresses a
specific aspect of software code. For example, one kind of
graph shows the structural information of software code,
and another one shows the inheritance relations across
software classes. Software visualization is a hot topic in
the software engineering domain [32]. Graphs give software
developers an indication of software size (or complexity
level). In addition, graphs present code information in its
simplest form to software developers. The current version
of ScaMaha visualizer can be easily extended to include
other kinds of graphs covering different aspects of software
code. Figure 2 briefly shows the use of ScaMaha tool in
this work.
Figure 2. An overview of ScaMaha tool.
In this study, the only input for ScaMaha is the OO
source code. The first step is aimed at parsing software
source code statically using the AST. The output produced
by ScaMaha code parser (i.e., parsed code) can be named as
metadata (i.e., an XML file called a code file). The parsed
code is saved into a code database for further use. The
second step of ScaMaha tool is aimed at analyzing the
software source code. The output produced via ScaMaha
code analyzer can be named as metadata (i.e., an XML
file called a software metrics file). The analyzed code
(i.e., software metrics) is kept in the tool database. Finally,

the third step of the suggested tool is aimed at visualizing
the software source code. Several graphs regarding software
code are produced and stored in the tool database (cf. Figure
2).
Figure 3 presents the use-case diagram of ScaMaha tool.
The use-case diagram shows all possible interactions be-
tween external users (i.e., software engineers) and ScaMaha.
The use-case diagram displays a collection of actions (called
use-cases) that are supported by the proposed tool, such
as parse and visualize software source code. This diagram
defines a collection of use-cases that ScaMaha tool can
execute in collaboration with end users to provide them
with significant outcomes regarding software code. The
source code of ScaMaha, the tutorial, the experimentation
results, case studies, and all materials regarding this study
are publicly available on ScaMaha web page [33], [34].
Figure 3. The use-case diagram of ScaMaha tool.
This paper proposes an automatic approach to analyzing
and visualizing OO software systems. ScaMaha tool is
the main outcome of this study. ScaMaha is a software
engineering tool. What distinguishes ScaMaha tool from
others is that it is extensible and can perform many tasks of
reverse engineering, such as source code visualization. With
ScaMaha, tool developers can develop advanced reverse
engineering tools that can exploit the existing components
of ScaMaha, like the meta-model and code parser. Figure 4
illustrates the main elements of ScaMaha approach.
Figure 4. The main elements of ScaMaha approach.
The rest of this paper is arranged as follows: Current
studies related to ScaMaha contributions are presented in
Section 2. ScaMaha is detailed in Section 3. Experiments
are given and discussed in Section 4. Finally, Section 5
concludes this study and provides proposals for future work.
2. Related Work
This section offers a literature review associated with
ScaMaha contributions. The closest works to ScaMaha are
chosen and offered in this section.
Bruneliere et al. [35] suggested a semantic and syntax
analysis based parser for the creation of AST and metrics
for multi-language software systems. Their meta-modeling
tool [36] is utilized to analyze multi-language applications
[37].
VerveineJ is a parser developed in Java that constructs
an MSE file from software source code [38]. Based on
Eclipse Java Development Tools (JDT), VerveineJ parses
software code written in Java to export it in the MSE format
that is utilized by the Moose data analysis platform [39],
[40]. Moreover, VerveineJ is used to extract relationships
(or dependencies) from software source code.

Janes et al. [41] proposed an uncommon open-source
solution that prevents producing parsers from scratch or
dealing with parser generators. They proposed and de-
scribed how to employ parsers included in the Eclipse
Integrated Development Environment (IDE) [42] to parse
software code, such as the JSDT parser [43].
Parsing and analyzing software source code is a critical
part of the reverse engineering process. Nowadays, several
source code parsers exist. Software engineers can utilize
those parsers to deal with numerous software engineering
activities, like software comprehension and visualization.
O’Hara and Slavin [44] described in their work a collection
of tools for parsing and analyzing many different program-
ming languages, involving legacy languages like Fortran.
Table I displays the main characteristics of ScaMaha tool.
TABLE I. ScaMaha tool characteristics.
ScaMaha code parser
Code entities (or identifiers)
Class Method
Package
Comment
Super-class
Interface
Attribute
Access
level
Comment
Parameter
list
Local
variable
Exception
× × × × × × × × × ×
Code relations (or dependencies)
Inheritance ✓
Attribute access ✓
Method invocation ✓
ScaMaha code analyzer
Code metrics
Lines of code ×
Number of packages ×
Number of classes ×
Number of attributes ×
Number of methods ×
Number of comments ×
Number of local variables ×
Number of inheritance relations ×
Number of attribute access relations ×
Number of method invocation relations ×
ScaMaha code visualizer
Code visualizations
Code organization ✓
Class inheritance relations ✓
Method invocation relations ✓
Polymetric view ✓
Tag cloud ✓
Wettel and Lanza [45] have suggested an automatic
tool called CodeCity. This tool visualizes software source
code as a city metaphor. CodeCity is an interactive, three-
dimensional software visualization tool [46]. CodeCity
shows the software code as a city, where the build-
ings (resp. districts) of the city represent software classes
(resp. packages). In CodeCity, building dimensions display
values of software metrics, like the number of methods or
the number of attributes [47]. While this study presents
an automatic tool called ScaMaha, which aims at parsing,
analyzing, and visualizing software source code. ScaMaha
visualizer generates several graphs regarding several aspects
of software code, such as code organization and relations.
The code parser is used in several feature identification
(aka. feature location) studies, such as in [28], [29], [30]. It
has been used to extract the main source code elements
(e.g., packages and classes) and relations (e.g., attribute
access and method invocation) from software products.
Also, code parsers are utilized to construct the feature model
[48], [49] from OO source code of a collection of software
product variants, such as in [10], [50], [51], [52], [53].
Moreover, code parser are exploited to visualize all software
identifier names as tag clouds (aka. word clouds), such as in
[54], [55], [56], [57]. Furthermore, parsers are employed to
identify the traceability links between software source code
and its artifacts (e.g., software requirements [58], [59]), such
as in [60], [61].
Code parsers are utilized to study OO software evolution
based on software identifiers and code relations, such as in
[62], [31]. Furthermore, code parsers are exploited in OO
source code summarization studies, such as in [63]. More-
over, code parsers are utilized in several studies concerning
software source code documentation, such as in [64], [25],
[65]. For more information about those parsers, interested
readers can refer to the published articles for more details.
All these studies show the value of code parsers in the
reverse engineering (resp. re-engineering) process.
The Java language has a wide variety of parsers due
to its long history of development, popularity, and huge
number of applications nowadays. Numerous tools exist
that turn software code into a tree-like structure, such as
interpreters and compilers. There are several Java parsers
for various contexts because there are so many different
Java applications, such as Spoon [66], SrcML [67], and
SuperParser [24].
The methods of software source code visualization have
become increasingly utilized to support software engineers
in software understanding [68]. In software visualization,
some methods aim at displaying software source code in a
recognized environment, like a forest [69] or a city [47].
Another method is to generate what is called a polymetric
view [70], described as a lightweight visualization tech-
nique supplemented with several metrics regarding software
code [32]. ScaMaha visualizes different aspects of software
source code, such as code organization and relations.
Specialized reverse engineering tools are important and
needed these days. Reverse engineering tools are required
to deal with the complexity of products and the particular

requirements of various tasks, like software comprehension
and reuse [71]. Thus, reverse engineering tools should fit
a wide range of circumstances. ScaMaha is a reverse engi-
neering tool for parsing, analyzing, and visualizing software
source code. Moose is a well-known reverse engineering
tool [72]. It began as a research project around 24 years ago.
MODMOOSE is the new version of Moose [1]. Tool de-
velopers can develop specialized reverse engineering tools
with MODMOOSE. Moose was based on the Famix meta-
model [27]. MODMOOSE uses FamixNG (a composable
meta-model of programming languages), where FamixNG
is a redesign of Famix. MODMOOSE utilizes Roassal
to script and display interactive graphs [73]. Roassal is
a visualization engine in MODMOOSE. MODMOOSE
mainly exploits Roassal to show code entities and their
relations in several forms or colors. MODMOOSE uses
the MSE file format to describe the source code models
[27]. Where the MSE has been utilized to save FamixNG
models. Thus, a software engineer uses an external parser
to generate the MSE file of software code, then loads the
MSE file into MODMOOSE in order to analyze or visualize
it. MODMOOSE is the closest tool to ScaMaha tool.
Lyons et al. [74] have suggested the lightweight mul-
tilingual software analysis method to analyze software
systems. They use several code parsers, one for every
programming language. The main goal of this work is to
create a software engineering tool that addresses large and
complex software systems in a lightweight and extensible
style. The current version of ScaMaha tool uses only one
code parser for the Java language.
A study of current approaches confirmed the need to
offer a comprehensive tool in order to analyze and visu-
alize outdated OO software systems. This work suggests
ScaMaha tool, which uses SCA to perform several activities
on software code, like code visualization and analysis. This
tool accepts only software code and produces a set of code
artifacts, which are the code file, code metrics file, and code
visualizations. Moreover, this tool helps software engineers
understand and maintain legacy software systems. Also,
software engineers can easily extend the current version of
the tool in order to include other functionalities.
3. Analyzing and Visualizing OO Source Code via
ScaMaha Tool
In this study, the author used Java as a target program-
ming language due to its wide adoption in the software
engineering field. The Java language is a popular target
for both semantic and syntactic code analysis, as well as
studies on code visualization [25], code summarization [63],
feature location [28], [29], and re-engineering of software
product variants into a Software Product Line (SPL) [10],
[50], [75], [76]. Application Programming Interfaces (APIs)
are available to access and manipulate Java code through
Eclipse development tools. Eclipse JDT project provides
access to Java code through AST and the Java model. The
Java model is displayed as a tree-like structure, and it is
used internally to represent each Java project. AST is a
comprehensive tree representation of software code.
ScaMaha relies on SCA in order to analyze and visualize
software source code. SCA is an important activity to check
software code and help discover potential problems early
in the cycle of software development before the software
system is deployed [7], [8]. It can discover defects or
faults that may be challenging to determine through manual
reviews of software code. ScaMaha is a tool for analyzing
and visualizing software source code without running it.
This study suggests an automatic approach to parse,
analyze, and visualize OO software system in a unique
manner. The main contribution of this work to the software
engineering field is to suggest ScaMaha tool. ScaMaha
accepts as input just software source code and produces as
output a set of software artifacts, like the code file, software
metrics file, and code graphs. ScaMaha tool bases itself
on static analysis of software source code. ScaMaha parser
extracts all code identifiers and relations. Then, ScaMaha
analyzer identifies comprehensive software code metrics,
and, at last, ScaMaha visualizer gives a set of graphs for
different aspects of software code. Figure 5 shows the
process of analyzing and visualizing software source code
using ScaMaha tool.
Figure 5. Analyzing and visualizing OO source code with ScaMaha
tool.
ScaMaha operates on a model of software source code,

Figure 6. The core of ScaMaha meta-model.
namely ScaMaha model. To analyze the OO software sys-
tem, you must first create a model of it using ScaMaha.
Figure 6 shows the core of ScaMaha meta-model. This meta
model shows the main OO software identifiers, like software
packages, classes, attributes, and methods. Moreover, this
meta model displays the main OO software relationships,
such as inheritance, method invocation, and attribute access.
The core of ScaMaha involves a language-independent
meta-model that can show several OO languages in a
uniform style. In most cases, the developer gets sufficient
information if he explores the basic types of entities that
model an OO software system. These are code identifiers
(e.g., package) and the relationships (e.g., inheritance) be-
tween them.
This model shows the majority of OO entities. For
instance, it shows that a method has parameters, comments,
and local variables. However, while this model doesn’t show
all OO entities, it is also valuable since, for most practical
purposes in the reverse engineering (resp. re-engineering)
process, it is all software developers need. Also, ScaMaha
model shows that a class (resp. package) has methods
(resp. classes), and a method (resp. class) belongs to a
class (resp. package). Furthermore, this model shows that
an inheritance relation denotes a connection between two
classes (i.e., the subclass and the superclass). Moreover,
ScaMaha model shows that an attribute access relation
denotes a connection between method and attribute. Also, it
shows that a method invocation relation means a connection
between one method and another method.
The first step of code analysis is to explore the software
directory (or any workspace) to select OO software that
the developers want to analyze. Thus, let’s say there is
a directory (repository) of OO software projects that de-
velopers need to analyze (e.g., the source code from the
Eclipse workspace). In this case, developers will browse
the directory to select a particular software project in order
to get a copy of its source code (cf. Figure 5). If software
developers want to analyze Java software, they can use any
directory, such as a git repository (i.e., GitHub) [77].
In the second step of ScaMaha, developers parse OO
source code to build ScaMaha model (cf. Figure 6). Once
developers have a copy of the software source code,
they can create a ScaMaha model of software code us-
ing ScaMaha parser. To parse OO source code, ScaMaha
depends on the static code parser. In this study, the most

1 
2 <Project Name="----">
3 <Packages>
4 <Package Name="----">
5 <Classes>
6 <Class Name="----" AccessLevel="----" isInterface="----" Superclass="----">
7 <SuperInterfaces>
8 <Interface InterfaceName="----" />
9 </SuperInterfaces>
10 <Comments>
11 <Comment CommentText="----" />
12 </Comments>
13 <Attributes>
14 <Attribute Name="----" AccessLevel="----" Type="----" isStatic="----" />
15 </Attributes>
16 <Methods>
17 <Method Name="----" AccessLevel="----" ReturnType="----" isStatic="----">
18 <Parameters NumberOfParameters="----">
19 <Parameter Name="----" Type="----" />
20 </Parameters>
21 <Comments>
22 <Comment CommentText="----" />
23 </Comments>
24 <LocalVariables>
25 <LocalVariable Name="----" Type="----" />
26 </LocalVariables>
27 <AttributeAccesses>
28 <Access Name="----" Type="----" HowIsItUsed="----" />
29 </AttributeAccesses>
30 <MethodInvocations>
31 <MethodInvocation Name="----" Arguments="----" />
32 </MethodInvocations>
33 <MethodAssignments>
34 <Assignment LeftHandSide="----" RightHandSide="----" />
35 </MethodAssignments>
36 <MethodExceptions>
37 <Exception ExceptionType="----" />
38 </MethodExceptions>
39 </Method>
40 </Methods>
41 </Class>
42 </Classes>
43 </Package>
44 </Packages>
45 </Project>
Listing 1. XML format corresponding to ScaMaha meta-model.
important entities of source code are considered and parsed,
such as packages, classes, methods, and attributes. Also,
key relations between main code entities (i.e., inheritance,
invocation, and access) are considered and parsed. ScaMaha
parser generates an XML file of software source code.
In this work, XML is a generic file format that repre-
sents ScaMaha code model. Thus, ScaMaha parser converts
OO source code to an XML file format. ScaMaha parser
produces an XML file for each software product. This file
includes all code entities (or identifiers) and relationships
(or dependencies) between those entities. Listing 1 shows
the XML format corresponding to ScaMaha meta-model.
As an illustrative example, this study considers the
mobile photo software system. ScaMaha used this software
to better explain its work. Mobile photo is open-source
software that allows users to manipulate photos on their
mobile devices [78]. This study considers the first release
of mobile photo software [79]. ScaMaha only utilizes the
source code of mobile photo as input. Listing 2 shows the
parsed code of mobile photo software as an XML file. The
parsed XML file includes structural information regarding
software code, such as that method “BaseThread” belongs
to class “BaseThread” and class “BaseThread” belongs to
package “ubc.midp.mobilephoto.core.threads”.
ScaMaha exploits Eclipse JDT and AST to parse soft-
ware systems written in Java. Several studies utilized
Eclipse AST to access, read, and manipulate the software
code. XML enables easy interchange of metadata between
several tools in diverse environments (cf. Figure 2). More-
over, XML is a human-readable format. The XML structure
matches the author’s requirements for the representation and

2 <Project Name="Mobile photo software">
3 <Packages>
4 <Package Name="ubc">
5 <Classes/>
6 </Package>
7 <Package Name="ubc.midp.mobilephoto.core">
8 <Classes/>
9 </Package>
10 <Package Name="ubc.midp.mobilephoto.core.threads">
11 <Classes>
12 <Class Name="BaseThread" AccessLevel="public" isInterface="false" Superclass="Object">
13 <Comments>
14 <Comment CommentText="Start the thread running"/>
15 </Comments>
16 <Attributes />
17 <Methods>
18 <Method Name="BaseThread" AccessLevel="public" ReturnType="void" isStatic="false">
19 <Parameters NumberOfParameters="0"/>
20 <LocalVariables />
21 <AttributeAccesses />
23 <MethodInvocation Name="println" Arguments="[BaseThread:: 0 Param Constructor used ... ]"/>
25 <MethodAssignments />
26 <MethodExceptions />
27 </Method>
28 <Method Name="run" AccessLevel="public" ReturnType="void" isStatic="false">
29 <Parameters NumberOfParameters="0"/>
30 <LocalVariables/>
31 <AttributeAccesses/>
33 <MethodInvocation Name="println" Arguments="[Starting BaseThread::run()]"/>
35 <MethodAssignments/>
36 <MethodExceptions/>
37 </Method>
38 </Methods>
39 </Class>
40 </Classes>
41 </Package>
42 </Packages>
43 </Project>
Listing 2. The code file of mobile photo software as an XML file (partial) [33].
description of ScaMaha model.
The chosen way to load a model in ScaMaha is through
an XML file. XML is a compact, simple, and robust
format. This study exploits XML to represent the core
of ScaMaha model. In order to analyze OO source code,
software developers need to load the code model as an
XML file into ScaMaha tool. ScaMaha analyzer aims at
analyzing software code and extracting useful software
code metrics. Developers can extend the current work of
ScaMaha analyzer by performing other analysis activities
on software code. Software developers can use ScaMaha
analyzer to obtain several code metrics. For instance, the
software LOC and the number of packages. The mined
code metrics file gives the software engineer an indication
about the size (complexity level) of the software system. In
this study, ScaMaha analyzer considers the software metrics
presented in Table II. Analyzer of ScaMaha can easily
extend to include other code metrics.
TABLE II. Software code metrics of ScaMaha code analyzer.
Metric Abbreviation
Lines of Code LOC
Number of Packages NOP
Number of Classes NOC
Number of Attributes NOA
Number of Methods NOM
Number of Comments NOCo
Number of local variables NOLv
Number of inheritance relations NOIn
Number of attribute access relations NOAc
Number of method invocation relations NOI
Source code metrics are measurements utilized to char-
acterize software code. A code metric is a useful quanti-

tative measure extracted from software’s source code. Size
is the most recognizable metric for software source code.
The number of LOC is the easiest method of measuring
software size. All code metrics given in Table II are static
code metrics. Static code metrics are metrics obtained
directly from software source code, like the LOC metric.
A subgroup of static code metrics are OO code metrics,
as they are also metrics obtained from software code itself,
such as NOIn, NOI, and NOAc metrics. Listing 3 shows the
extracted software code metrics from mobile photo software
by ScaMaha analyzer.
2 <Project ProjectName="Mobile photo software">
3 <Metrics>
4 <LinesOfCode LOC="1229" />
5 <NumberOfPackages NOP="10" />
6 <NumberOfClasses NOC="15" />
7 <NumberOfAttributes NOA="56" />
8 <NumberOfMethods NOM="91" />
9 <NumberOfComments NOCo="250" />
10 <NumberOfInheritances NOIn="14" />
11 <NumberOfInvocations NOI="298" />
12 <NumberOfAccesses NOAc="631" />
13 </Metrics>
14 </Project>
Listing 3. Software code metrics for mobile photo software.
In this work, the use of visualization speeds up the
comprehension of legacy OO source code. By utilizing
ScaMaha to analyze and visualize software source code,
software developers are able to speed their maintenance,
reuse, and comprehension of software products. Source
code visualization aims at producing graphical representa-
tions (or annotations) of software code in order to help
comprehend and analyze it. In the software engineering
domain, the code visualization process plays an important
role in understanding how large software products work
[25].
The main goal of ScaMaha visualizer is to visual-
ize software code entities and relations. All code entities
and relations are defined in ScaMaha core meta-model
(cf. Figure 6). To visualize software code via ScaMaha
visualizer, software developers need to load code files using
ScaMaha’s importer. Then, the suggested tool will generate
different visualizations covering several aspects of software
code. ScaMaha exporter stores all code visualizations in
the tool workspace. Thus, software developers can explore
ScaMaha’s workspace to see all the code visualizations.
Software developers study code visualizations in order to
analyze and understand software products. Figure 7 briefly
shows the core parts of ScaMaha tool.
ScaMaha visualizes several aspects of software code.
The visualization of code organization shows the main code
entities as boxes. Code organization visualization represents
software packages, classes, and methods. Developers can
easily extend the current visualization by adding other
entities of code, like software attributes. Figure 8 shows the
code organization visualization of mobile photo software.
Figure 7. An overview of the core parts of ScaMaha tool.
The main objective of this visualization is to show the
organization of code in terms of packages, classes, and
methods
Figure 8. Code organization visualization of mobile photo software
(partial) [33].

In code organization visualization, the big box repre-
sents the whole software code, while other boxes represent
main code entities. This visualization shows that the box
may contain other boxes. For instance, the package box
includes all classes belonging to this package. Also, the
class box includes all methods belonging to this class
(cf. Figure 8).
Furthermore, code organization visualization provides
software engineers with structural information about soft-
ware code. Structural information is the way developers
arrange and group software code elements such as package,
class, methods, and attributes. In this work, well-structured
information about code entities makes software code easier
to understand by software engineers (cf. Figure 8).
ScaMaha also generates a polymetric view of software
source code. This view depends on software packages.
Where it represents each software package as a box includ-
ing a set of package metrics. The name of each package is
placed on the top of the box. ScaMaha approach considers
the following metrics for each package: LOC, NOC, NOA,
NOM, NOCo, NOLv, NOIn, NOI, and NOAc. Figure 9
shows a polymetric view of mobile photo software.
Figure 9. Polymetric view of mobile photo software based on its
packages. This view uses the following metrics for each package:
LOC, NOC, NOA, NOM, NOCo, NOLv, NOIn, NOI, and NOAc
(partial) [33].
In this work, ScaMaha visualizes inheritance relations
between software classes. The main goal of inheritance
relationships is to minimize code complexity and size. The
inheritance relationship gives an indication of the strong
connection between software classes. The visualization of
class inheritance relations gives important information about
legacy (or outdated) code. This kind of visualization helps
software developers when they want to analyze, reuse,
understand, and maintain existing code. Figure 10 shows
ScaMaha visualization of class inheritance relations for
mobile photo software.
Figure 10. Visualization of class inheritance relations for mobile
photo software (partial) [33].
In OO language, a method is a function defined inside a
class. Thus, a software class may contain several methods.
Method communicates with other methods in software via
method invocation relations. So, method invocation occurs
between software methods when a method calls (or invokes)
other methods. Thus, a particular method may invoke other
methods of the same class or of different classes (cf. Figure
11). Usually, a method calls another method by using its
name and arguments. Also, methods invoke other methods
in order to achieve specific functionality. This study con-
siders method invocation as an important code relationship.
ScaMaha visualizes invocation relations across software
methods in a perfect way. Software developers explore the
extracted visualization in order to comprehend the software
code. Figure 11 shows ScaMaha visualization of method
invocation relations for mobile photo software.
ScaMaha approach evaluates the produced results using
precision, recall, and F-measure metrics [80]. For source
code identifiers and relations, the precision metric is the
percentage of correctly recovered identifiers (resp. relations)
to the total number of recovered identifiers (resp. relations).
While the recall metric is the percentage of correctly
recovered identifiers (resp. relations) to the total number of
relevant identifiers (resp. relations). Finally, the F-measure

Figure 11. Visualization of method invocation relations for mobile
photo software (partial) [33].
metric quantifies a trade-off among precision and recall
metrics; thus, it provides a high value just in cases where
both recall and precision metrics are high.
All evaluation metrics of ScaMaha have values between
zero (0%) and one (100%). If the recall metric is equal to
100%, this means that all relevant identifiers (or relations)
are recovered. If the precision metric is equal to 100%, this
means that all retrieved identifiers (or relations) are relevant.
If the F-measure metric is equal to 100%, this means that
both recall and precision are high (100%) [10].
In mobile photo software, the proposed approach returns
15 classes from the software code. In this case, the values of
all evaluation metrics are equal to 100% since the software
code actually contains only 15 classes. Furthermore, for the
method invocation relations, ScaMaha returns 298 relations
from the software code. In this circumstance, the values
of all evaluation metrics are equal to 100% since the
software code actually contains 298 invocation relations.
For software code metrics, the retrieved value of each metric
is totally correct. Thus, the values of all evaluation metrics
are equal to 100%. For code visualizations, all types of
code visualizations have high accuracy. For instance, in
mobile photo software, the visualization of class inheritance
relations obviously shows the 14 inheritance relations. In
this case, the values of all evaluation metrics are equal
to 100%. Mobile photo is well-documented software [79].
Thus, all code entities, metrics, and relations are known in
advance. Therefore, the available software documentation
helps in comparing ScaMaha results against it.
ScaMaha tool in a nutshell: ScaMaha is a tool for software
code analysis and visualization. Also, it is a creative tool
to navigate, analyze, and visualize OO software systems.
Moreover, ScaMaha helps software developers to cheaply
construct custom analyses of software code. ScaMaha im-
plementation is based on Java, and it’s an open-source tool.
ScaMaha can’t be used to analyze the dynamic execution of
software. So, it uses SCA, which is a method of exploring
the software code without running it. The current version
of ScaMaha is shipped with a Java code parser. Also,
this tool uses the XML structure to represent software
code. Thus, XML is a file format that describes ScaMaha
meta-model. XML is generated by an internally provided
code parser. In this work, ScaMaha meta-model is an
abstract representation of software source code. In general,
it presents software code entities and relations. The code
meta-model of ScaMaha is a generic model, and it may
describe software systems written in Java and C++ (i.e., OO
languages). Also, ScaMaha tool includes a code analyzer
and visualizer. The code analyzer (resp. visualizer) uses
the generated XML file from the code parser. ScaMaha
analyzer (resp. visualizer) generates software code metrics
(resp. visualizations). ScaMaha visualizer is an integral part
of the tool that allows developers to visualize dependen-
cies between classes and methods. In addition, ScaMaha
visualizer gives a polymetric view of software based on
its packages. Also, it reveals, in a unique visualization,
the organization (or structure) of software code. Software
engineers view and explore the generated code artifacts
via ScaMaha tool to understand and analyze the chosen
software systems.
4. Experimentation
This section presents the case studies used in this
work. Also, it presents and discusses the obtained results.
Furthermore, it mentions threats to the validity of ScaMaha
approach.
ScaMaha runs experiments on several software systems,
such as drawing shapes [60], mobile photo [78], health
watcher [81], Rhino [82], and ArgoUML [83]. Drawing
shapes software allows users to draw several kinds of

shapes, such as ovals and lines [84]. Mobile photo is
introduced and used in Section 3. The health watcher
software is a web-based information system that enables
users to register complaints about health issues. In this
study, the experiment ran on the last version of health
watcher software (i.e., version 10) [85]. Moreover, Rhino
is software for JavaScript developed in Java. In this study,
the experiment ran on version 1.7R2 of Rhino. While
ArgoUML is an open-source software written in Java [86].
It is widely utilized for designing software systems in
Unified Modeling Language (UML). It is a large and
complex software system (i.e., 271690 LOC). In this work,
all experiments are executed on a 2.40 GHz Intel Core i7
PC with 8 GB of RAM. Table III briefly presents the results
obtained from all experiments.
In this work, all important information from the software
source code is parsed to form the software code file. Listing
4 illustrates the parsed code from the drawing shapes
software as an XML file.
2 <Project Name="Drawing shapes software">
3 <Packages>
4 <Package Name="Drawing.Shapes.coreElements">
5 <Classes>
6 <Class Name="MyLine" AccessLevel="public"
isInterface="false" Superclass="MyShape
">
7 <SuperInterfaces />
8 <Comments>
9 <Comment CommentText="Class that
declares a line object" />
10 </Comments>
11 <Attributes />
12 <Methods>
13 <Method Name="draw" AccessLevel="public
" ReturnType="void" isStatic="
false">
14 <Parameters NumberOfParameters="1">
15 <Parameter Name="g" Type="Graphics
" />
16 </Parameters>
17 <LocalVariables />
18 <AttributeAccesses>
19 <AttributeAccess Name="g" Type="
Graphics" HowIsItUsed="g.
setColor(getColor())" />
20 </AttributeAccesses>
22 <MethodInvocation Name="setColor"
Arguments="[getColor()]" />
24 <MethodAssignments />
25 <MethodExceptions />
26 </Method>
27 </Methods>
28 </Class>
29 </Classes>
30 </Package>
31 </Packages>
32 </Project>
Listing 4. The code file of drawing shapes software as an XML file
(partial) [33].
In this work, the different sizes of software systems
show the scalability of ScaMaha to work with such systems
(i.e., small, medium, and large systems). Moreover, all
software systems are well documented. Thus, the results
of ScaMaha are measurable. In addition, all case studies
are well known and employed to assess many approaches
in the field of this study (i.e., SCA).
During software maintenance, software engineers con-
sume a considerable amount of time analyzing legacy
software system source code in order to understand it.
Furthermore, the cost of software maintenance accounts
for 50% to 75% of the total cost of the software prod-
uct [87]. Thus, comprehending software source code is
one of the most challenging activities in the maintenance
(resp. comprehension) of software products. Listing 5 shows
the extracted code metrics from drawing shapes software.
2 <Project ProjectName="Drawing shapes software">
3 <Metrics>
13 </Metrics>
14 </Project>
Listing 5. Software code metrics for drawing shapes software.
Listing 6 shows the obtained code metrics from Ar-
goUML software. Software developers can easily detect that
ArgoUML is a large software system using the extracted
code metrics (e.g., the number of software classes is equal
to 1939).
2 <Project ProjectName="ArgoUML software">
3 <Metrics>
10 <NumberOfLocalVariables NOLv="10874" />
14 </Metrics>
15 </Project>
Listing 6. Software code metrics for ArgoUML software.
Usually, software engineers hope to get all code infor-
mation (e.g., software identifiers and relations) to exploit
this information in many software engineering activities
(e.g., maintenance, re-engineering, visualization, documen-
tation, and reverse engineering). Listing 7 shows the ob-
tained code metrics from health watcher software.

TABLE III. ScaMaha results for all experiments (i.e., case studies).
ID Case study Software Software artifacts Execution Visualization
size Code Metrics file time (in ms) Codea
Classb
Methodc
Polymetricd
Cloude
1 Drawing shapes Small ✓ ✓ 2095 × × × × ×
2 Mobile photo Medium ✓ ✓ 2850 × × × × ×
3 Health watcher Medium ✓ ✓ 5031 × × × × ×
4 Rhino Medium ✓ ✓ 7965 × × × × ×
5 ArgoUML Large ✓ ✓ 31698 × × × × ×
a Code organization, b Class inheritance relations, c Method invocation relations, d Polymetric view, e Tag cloud.
2 <Project ProjectName="Health watcher software">
3 <Metrics>
14 </Metrics>
15 </Project>
Listing 7. Software code metrics for health watcher software.
The obtained metrics for software code give an indi-
cation of software size (or complexity level). A software
metrics file gives software engineers rapid information
about software code, like the number of software methods.
Listing 8 shows the obtained code metrics from Rhino
software.
2 <Project ProjectName="Rhino software">
3 <Metrics>
14 </Metrics>
15 </Project>
Listing 8. Software code metrics for Rhino software.
One of the main contributions of ScaMaha approach
is to give a polymetric view of software packages. In
this study, polymetric view is a lightweight visualization
method of software source code [70]. Polymetric views
supplemented with unique metrics about software source
code [68]. Polymetric views assist software engineers in
understanding the complexity level of software code in the
reverse engineering process. Figure 12 shows a polymetric
view of drawing shapes software based on its packages. This
view uses the following metrics for each package: LOC,
NOC, NOA, NOM, NOCo, NOLv, NOIn, NOI, and NOAc.
Figure 12 shows that drawing shapes software consists of
two packages. Also, several metrics regarding each package
are given in Figure 12.
Software visualization is an important activity in the
software engineering domain. Source code visualization is
a real implementation of the quote, “A picture is worth
a thousand words.”. Code visualization gives developers
better information compared to textual code information.
ScaMaha visualizations are a real reflection of software
code. ScaMaha visualizes code identifiers and relations
correctly. The visualizer accepts as input the code file
and generates as output a collection of code visualizations.
Figure 13 shows ScaMaha visualization of class inheritance
relations from drawing shapes software.
Figure 13. Visualization of class inheritance relations for drawing
shapes software.
Figure 13 gives different views of software code,
where it presents structural information (e.g., MyLine class
belongs to the coreElements package), identifier names
(e.g., MyShape class), and inheritance relations (e.g., My-
Line class inherits attributes and methods of MyShape class)

Figure 12. Polymetric view of drawing shapes software based on its packages. This view uses the following metrics for each package: LOC, NOC,
NOA, NOM, NOCo, NOLv, NOIn, NOI, and NOAc.
from drawing shapes software.
Figure 14 represents a tag cloud generated from the
source code of the drawing shapes software by ScaMaha. It
displays key software identifiers such as package names,
class names, attribute names, and method names, with
larger tags indicating higher frequency and importance. Tag
frequencies are shown in red within square brackets.
Figure 14. Tag cloud extracted from the drawing shapes software
using ScaMaha.
The obtained results from all experiments show that all
evaluation metrics (i.e., precision, recall, and F-measure)
appear high (i.e., 100%) for all artifacts extracted from
software source code, such as code and metrics files and
code visualizations. This means that all resulted artifacts
(e.g., code visualizations) from software code are relevant
and correct. In this study, the author uses two resources
to evaluate the obtained results. The first is the available
software documents, and the second is the manual review
of software code.
Results show the ability of ScaMaha to retrieve all soft-
ware identifiers (e.g., software classes and attributes) from
any software system. Also, the results show that ScaMaha
is able to retrieve all code comments (i.e., class and method
comments). Moreover, ScaMaha tool is capable of retrieving
all elements of the method body (i.e., parameter list, local
variable, method invocation, and attribute access). Thus,
ScaMaha guarantees that software developers will not lose
any code identifier or relation from the software code.
ScaMaha tool consists of three basic components, which
are the code parser, analyzer, and visualizer. Moreover,
ScaMaha exploits and reuses two components, which are the
JDOM [88] and Graphviz libraries [89]. ScaMaha compo-
nent accepts software code as input and produces as output
a collection of code artifacts (e.g., software metrics file).
The parser component accepts software code and generates
the code file, while the analyzer component accepts the
code file and generates a software metrics file. Finally, the
visualizer component receives the code file as input and
creates several code visualizations as outputs. Figure 15
shows an architectural view of ScaMaha tool in a simplified
structure.
By viewing the extracted software metrics file, the
software developers can easily determine the size and com-
plexity level of the analyzed software. For instance, based
on the mined code metrics file, drawing shapes software
is considered as a small software (cf. Listing 5), while
ArgoUML is considered as a large and complex software
system (cf. Listing 6). The software metrics file includes
unique code metrics, like the number of inheritance rela-
tions between software classes. The originality of ScaMaha
analyzer is that it exploits all important code metrics to
determine the size and complexity of software code.

Figure 15. An architectural view of ScaMaha tool in a simplified structure.
Table III shows the results obtained for each case
study using ScaMaha tool. It shows the extracted code
file (resp. code metrics file) for each case study. Also, it
shows the mined code visualizations for each case study.
Moreover, the time needed to parse, analyze, and visualize
each case study in ms is given in Table III (i.e., execution
time). Results show the ability of ScaMaha to work with
different software system sizes (i.e., small and large soft-
ware systems). Also, results show the ability of ScaMaha
visualizer to provide several visualizations of software code.
Thanks to ScaMaha tool, software developers can easily
parse, analyze, and visualize OO software systems. Com-
plete results of ScaMaha experiments are available on the
tool’s webpage [33].
In conclusion, software engineers can use ScaMaha tool
for several tasks during their daily work, like parsing,
analyzing, and visualizing software source code. ScaMaha
tool targets several areas of the software engineering field,
like software comprehension, visualization, and mainte-
nance [90]. The current version of the tool only works with
software systems written entirely in Java (cf. Figure 16). In
this case, there is a threat to the validity of the prototype,
which restricts the ability of ScaMaha implementation to
work only with software systems written in Java. To solve
this problem, there is a need to develop a parser for each
programming language, like C++. But the parser should
generate a code file identical to the XML file that is used
Figure 16. The Java implementation of ScaMaha tool.

by ScaMaha’s tool. Then, developers can import a code file,
load it into ScaMaha tool, and continue to perform other
tasks (i.e., code analysis and visualization).
5. Conclusion and Future Work
This paper has presented ScaMaha, a tool for pars-
ing, analyzing, and visualizing OO source code like Java.
ScaMaha is designed to prevent software engineers from
wasting their resources, like effort and time, on manual
review of software source code in order to understand
it. The main goal of ScaMaha tool is to assist software
engineers in the process of understanding complex and
large-sized software systems. Various categories of users,
such as scholars in the field of software analysis and tool
creators, will exploit ScaMaha tool in their works.
In summary, ScaMaha extracts code identifiers and
relationships, generates a metrics file with statistical data,
and produces unique graphs to effectively visualize software
code. ScaMaha had been validated and evaluated on several
case studies, including drawing shapes, mobile photo, health
watcher, rhino, and ArgoUML software. The results of the
experiments show the capacity of ScaMaha to recover all
software artifacts in an efficient and accurate manner. The
evaluation metrics of ScaMaha, like precision and recall,
show the accuracy of ScaMaha in parsing, analyzing, and
visualizing software source code, as all source code artifacts
were correctly obtained.
Regarding ScaMaha’s future work, the author plans to
extend the current tool by developing a comprehensive
tool’s parser for all OO languages, like Java and C++.
Moreover, additional experimental tests can be performed
to verify ScaMaha contributions utilizing open-source and
industrial software systems. Also, the author plans to con-
duct a comprehensive survey regarding current approaches
that relate to ScaMaha contributions. Finally, the author
of ScaMaha tool plans to extend the current work by
developing a general tool for performing various kinds of
analyses and visualizations of any OO software system.
References
[1] N. Anquetil, A. Etien, M. H. Houekpetodji, B. Verhaeghe,
S. Ducasse, C. Toullec, F. Djareddir, J. Sudich, and M. Derras,
“Modular moose: A new generation of software reverse engineering
platform,” in Reuse in Emerging Software Engineering Practices,
S. Ben Sassi, S. Ducasse, and H. Mili, Eds. Cham: Springer
International Publishing, 2020, pp. 119–134.
[2] W. Pan, X. Du, M. Hua, D. Kim, and Z. Yang, “Identifying
key classes for initial software comprehension: Can we do
it better?” in 45th IEEE/ACM International Conference on
Software Engineering, ICSE 2023, Melbourne, Australia, May
14-20, 2023. IEEE, 2023, pp. 1878–1889. [Online]. Available:
https://doi.org/10.1109/ICSE48619.2023.00160
[3] N. M. Salem, S. I. Serhan, K. M. Al-Tarawneh, and R. Al-
Msie’deen, “Flexible and cost-effective spherical to cartesian
coordinate conversion using 3-D CORDIC algorithm on FPGA,”
International Journal of Intelligent Systems and Applications in
Engineering, vol. 12, no. 4, pp. 815–823, Jun. 2024. [Online]. Avail-
able: https://www.ijisae.org/index.php/IJISAE/article/view/6302
[4] A. A. 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.
[Online]. Available: https://article.nadiapub.com/IJDTA/vol8 no1/
14.pdf
[5] R. Al-Msie’deen, “Amman city, Jordan: Toward a sustainable city
from the ground up,” arXiv preprint arXiv:2408.01454, pp. 1–12,
2024. [Online]. Available: https://arxiv.org/pdf/2408.01454
[6] R. A. Al-Msie’deen, “Smart city: Definitions, architectures, devel-
opment life cycle, technologies, application domains, case studies,
challenges and opportunities,” 2024, Mutah University.
[7] H. Prähofer, F. Angerer, R. Ramler, H. Lacheiner, and
F. Grillenberger, “Opportunities and challenges of static code
analysis of IEC 61131-3 programs,” in Proceedings of 2012
IEEE 17th International Conference on Emerging Technologies &
Factory Automation, ETFA 2012, Krakow, Poland, September
17-21, 2012. IEEE, 2012, pp. 1–8. [Online]. Available:
https://doi.org/10.1109/ETFA.2012.6489535
[8] I. Elkhalifa and B. Ilyas, “Static code analysis: a systematic literature
review and an industrial survey,” Master’s thesis, Blekinge Institute
of Technology, Department of Software Engineering, 2016.
[9] A. Trautsch, J. Erbel, S. Herbold, and J. Grabowski, “What really
changes when developers intend to improve their source code:
a commit-level study of static metric value and static analysis
warning changes,” Empir. Softw. Eng., vol. 28, no. 2, p. 30, 2023.
[Online]. Available: https://doi.org/10.1007/s10664-022-10257-9
[10] R. Al-Msie’deen, “Reverse engineering feature models from
software variants to build software product lines: REVPLINE ap-
proach,” Ph.D. dissertation, Montpellier 2 University, France, 2014,
[Online]. Available: https://tel.archives-ouvertes.fr/tel-01015102
(Accessed: Nov. 18, 2024).
[11] D. de silva, P. Samarasekara, and R. Hettiarachchi, “A
comparative analysis of static and dynamic code analysis
techniques,” TechRxiv, 5 ”2023. [Online]. Available: https:
//www.techrxiv.org/articles/preprint/A Comparative Analysis
of Static and Dynamic Code Analysis Techniques/22810664
[12] I. Sommerville, Software Engineering, 8. Auflage, ser. it : Infor-
matik. Pearson Studium, 2007.
[13] J. J. Vinju, “Analysis and transformation of source code by parsing
and rewriting,” Ph.D. dissertation, University of Amsterdam, 15
November 2005, [Online]. Available: https://pure.uva.nl/ws/files/
3816121/37819 Vinju.pdf (Accessed: Nov. 18, 2024).
[14] G. Menguy, “Black-box code analysis for reverse engineering
through constraint acquisition and program synthesis. (analyse de
code en boı̂te noire pour la rétro ingénierie via acquisition de
contraintes et synthèse de code),” Ph.D. dissertation, University
of Paris-Saclay, France, 2023. [Online]. Available: https://tel.
archives-ouvertes.fr/tel-04097552
[15] A. Jain, S. Soner, and A. Gadwal, “Reverse engineering: Journey
from code to design,” in 2011 3rd International Conference on
Electronics Computer Technology, vol. 5, 2011, pp. 102–106.
[16] W. K. G. Assunção, S. R. Vergilio, and R. E. Lopez-Herrejon,
“Reengineering UML class diagram variants into a product line
architecture,” in UML-Based Software Product Line Engineering

with SMarty, E. OliveiraJr, Ed. Springer, 2023, pp. 393–414.
[Online]. Available: https://doi.org/10.1007/978-3-031-18556-4 18
[17] M. Majthoub, M. H. Qutqut, and Y. Odeh, “Software re-engineering:
An overview,” in 2018 8th International Conference on Computer
Science and Information Technology (CSIT), 2018, pp. 266–270.
[18] Z. Mushtaq, G. Rasool, and B. Shehzad, “Multilingual source
code analysis: A systematic literature review,” IEEE Access,
vol. 5, pp. 11 307–11 336, 2017. [Online]. Available: https:
//doi.org/10.1109/ACCESS.2017.2710421
[19] B. Kitchenham, T. Dyba, and M. Jorgensen, “Evidence-based soft-
ware engineering,” in Proceedings. 26th International Conference
on Software Engineering. IEEE, 2004, pp. 273–281.
[20] F. Angerer, A. Grimmer, H. Prähofer, and P. Grünbacher, “Change
impact analysis for maintenance and evolution of variable software
systems,” Autom. Softw. Eng., vol. 26, no. 2, pp. 417–461, 2019.
[Online]. Available: https://doi.org/10.1007/s10515-019-00253-7
[21] T. B. C. Arias, P. Avgeriou, and P. America, “Analyzing the actual
execution of a large software-intensive system for determining
dependencies,” in WCRE 2008, Proceedings of the 15th Working
Conference on Reverse Engineering, Antwerp, Belgium, October
15-18, 2008, A. E. Hassan, A. Zaidman, and M. D. Penta, Eds.
IEEE Computer Society, 2008, pp. 49–58. [Online]. Available:
https://doi.org/10.1109/WCRE.2008.11
[22] C. Zhang, J. Wang, Q. Zhou, T. Xu, K. Tang, H. Gui, and
F. Liu, “A survey of automatic source code summarization,”
Symmetry, vol. 14, no. 3, p. 471, 2022. [Online]. Available:
https://doi.org/10.3390/sym14030471
[23] H. Washizaki, Y.-G. Guéhéneuc, and F. Khomh, “A taxonomy for
program metamodels in program reverse engineering,” in 2016 IEEE
International Conference on Software Maintenance and Evolution
(ICSME), 2016, pp. 44–55.
[24] I. Utkin, E. Spirin, E. Bogomolov, and T. Bryksin, “Evaluating
the impact of source code parsers on ML4SE models,” CoRR,
vol. abs/2206.08713, 2022. [Online]. Available: https://doi.org/10.
48550/arXiv.2206.08713
[25] R. Al-Msie’deen, “Visualizing object-oriented software for under-
standing and documentation,” International Journal of Computer
Science and Information Security (IJCSIS), vol. 13, no. 5, pp. 18–
27, 2015.
[26] B. Bellay and H. C. Gall, “A comparison of four reverse
engineering tools,” in 4th Working Conference on Reverse
Engineering, WCRE ’97, Amsterdam, The Netherlands, October
6-8, 1997, I. D. Baxter, A. Quilici, and C. Verhoef, Eds.
IEEE Computer Society, 1997, pp. 2–11. [Online]. Available:
https://doi.org/10.1109/WCRE.1997.624571
[27] S. Ducasse, N. Anquetil, M. U. Bhatti, A. C. Hora, J. Laval, and
T. Gı̂rba, “MSE and FAMIX 3.0: an interexchange format and
source code model family,” 2011, [Online]. Available: https://inria.
hal.science/hal-00646884/document (Accessed: Nov. 18, 2024).
[28] 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.
[29] R. A. 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. IEEE Computer Society, 2013, pp. 586–593. [Online].
Available: https://doi.org/10.1109/IRI.2013.6642522
[30] 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. Knowledge Systems Institute Graduate
School, 2013, pp. 244–249.
[31] R. Al-Msie’deen and A. Blasi, “The impact of the object-oriented
software evolution on software metrics: The iris approach,” Indian
Journal of Science and Technology, vol. 11, no. 8, pp. 1–8, 2018.
[32] P. Lima, J. Melegati, E. Gomes, N. S. Pereira, E. M. Guerra,
and P. Meirelles, “CADV: A software visualization approach for
code annotations distribution,” Inf. Softw. Technol., vol. 154, p.
107089, 2023. [Online]. Available: https://doi.org/10.1016/j.infsof.
2022.107089
[33] R. A. A. Al-Msie’deen. (2024) ScaMaha. [Online].
Available: https://drive.google.com/drive/folders/11 CItJ2pPq
1CAWswcjRsAZnhmQO6OQ8 (Accessed: Nov. 18, 2024).
[34] R. Al-Msie’deen. (2024) ScaMaha. Accessed: Nov. 18, 2024.
[Online]. Available: https://github.com/rafat66/ScaMaha
[35] H. Bruneliere, J. Cabot, F. Jouault, and F. Madiot, “Modisco:
a generic and extensible framework for model driven reverse
engineering,” in ASE 2010, 25th IEEE/ACM International
Conference on Automated Software Engineering, Antwerp, Belgium,
September 20-24, 2010, C. Pecheur, J. Andrews, and E. D.
Nitto, Eds. ACM, 2010, pp. 173–174. [Online]. Available:
https://doi.org/10.1145/1858996.1859032
[36] H. Bruneliere. (2010) MoDisco. [Online]. Available: https://www.
eclipse.org/MoDisco/ (Accessed: Nov. 18, 2024).
[37] H. Bruneliere, J. Cabot, G. Dupé, and F. Madiot, “Modisco:
A model driven reverse engineering framework,” Inf. Softw.
Technol., vol. 56, no. 8, pp. 1012–1032, 2014. [Online]. Available:
https://doi.org/10.1016/j.infsof.2014.04.007
[38] Moose VerveineJ. (2023) VerveineJ. [Online]. Available: https:
//modularmoose.org/moose-wiki/Developers/Parsers/VerveineJ.html
(Accessed: Nov. 18, 2024).
[39] Moose Technology. (2022) VerveineJ. [Online]. Available: https://
github.com/moosetechnology/VerveineJ (Accessed: Nov. 18, 2024).
[40] Moose. (2023) MooseTechnology. [Online]. Available: https://
modularmoose.org/ (Accessed: Nov. 18, 2024).
[41] A. Janes, D. Piatov, A. Sillitti, and G. Succi, “How to
calculate software metrics for multiple languages using open
source parsers,” in Open Source Software: Quality Verification
- 9th IFIP WG 2.13 International Conference, OSS 2013,
Koper-Capodistria, Slovenia, June 25-28, 2013. Proceedings, ser.

IFIP Advances in Information and Communication Technology,
vol. 404. Springer, 2013, pp. 264–270. [Online]. Available:
https://doi.org/10.1007/978-3-642-38928-3 20
[42] Eclipse. (2023) Eclipse IDE. [Online]. Available: https://www.
eclipse.org/ide/ (Accessed: Nov. 18, 2024).
[43] JSDT. (2023) Javascript Development Tools (JSDT). [Online].
Available: https://www.eclipse.org/webtools/jsdt/ (Accessed: Nov.
18, 2024).
[44] S. O’Hara and R. Slavin, “Modernizing parsing tools: parsing and
analysis with object-oriented programming,” in Proceedings of the
8th ACM SIGPLAN International Workshop on State Of the Art
in Program Analysis, SOAP@PLDI 2019, Phoenix, AZ, USA, June
22, 2019, N. Grech and T. Lavoie, Eds. ACM, 2019, pp. 20–25.
[Online]. Available: https://doi.org/10.1145/3315568.3329967
[45] R. Wettel and M. Lanza, “Visualizing software systems as cities,” in
Proceedings of the 4th IEEE International Workshop on Visualizing
Software for Understanding and Analysis, VISSOFT 2007, Banff,
Alberta, Canada, June 25-26, 2007, J. I. Maletic, A. C. Telea,
and A. Marcus, Eds. IEEE Computer Society, 2007, pp. 92–99.
[Online]. Available: https://doi.org/10.1109/VISSOF.2007.4290706
[46] D. Moreno-Lumbreras, R. Minelli, A. Villaverde, J. M. González-
Barahona, and M. Lanza, “Codecity: A comparison of on-screen
and virtual reality,” Inf. Softw. Technol., vol. 153, p. 107064, 2023.
[Online]. Available: https://doi.org/10.1016/j.infsof.2022.107064
[47] R. Wettel, M. Lanza, and R. Robbes, “Software systems as
cities: a controlled experiment,” in Proceedings of the 33rd
International Conference on Software Engineering, ICSE 2011,
Waikiki, Honolulu , HI, USA, May 21-28, 2011, R. N. Taylor,
H. C. Gall, and N. Medvidovic, Eds. ACM, 2011, pp. 551–560.
[48] R. AL-msie’deen, M. Huchard, A.-D. Seriai, C. Urtado, S. Vauttier,
and A. Al-Khlifat, “Concept lattices: A representation space to
structure software variability,” in 2014 5th International Conference
on Information and Communication Systems (ICICS), 2014, pp. 1–6.
[49] R. A. A. Al-Msie’deen, “Mining feature models from the object-
oriented source code of a collection of software product variants,”
in Doctoral Symposium of European Conference on Object-Oriented
Programming (ECOOP 2013),, Montpellier, France, July 2013, pp.
1–10.
[50] R. Al-Msie’deen, M. Huchard, and C. Urtado, Reverse Engineering
Feature Models. LAP LAMBERT Academic Publishing, 2014,
iSBN: 9783659614521.
[51] 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,” Int. J. Softw. Eng. Knowl. Eng., vol. 24, no. 10, pp.
1413–1438, 2014.
[52] R. A. A. 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, Košice, Slovakia, October 7-10, 2014, ser.
CEUR Workshop Proceedings, K. Bertet and S. Rudolph, Eds.,
vol. 1252. CEUR-WS.org, 2014, pp. 95–106. [Online]. Available:
https://ceur-ws.org/Vol-1252/cla2014 submission 13.pdf
[53] 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, M. Z. Reformat, Ed. Knowledge Systems Institute
Graduate School, 2014, pp. 138–143.
[54] R. Al-Msie’deen, “Tag clouds for object-oriented source code
visualization,” Engineering, Technology & Applied Science
Research, vol. 9, no. 3, pp. 4243–4248, 2019. [Online].
Available: https://doi.org/10.48084/etasr.2706
[55] R. A. Al-Msie’deen, “Softcloud: A tool for visualizing software
artifacts as tag clouds,” Mutah Lil-Buhuth wad-Dirasat - Natural
and Applied Sciences Series, vol. 37, no. 2, pp. 93–116, 2022.
[56] R. Al-Msie’deen, “Tag clouds for software documents visualization,”
International Journal on Informatics Visualization, vol. 3, no. 4, pp.
361–364, 2019.
[57] R. Al-Msie’deen, H. E. Salman, A. H. Blasi, and M. A. Alsuwaiket,
“Naming the identified feature implementation blocks from software
source code,” Journal of Communications Software and Systems,
vol. 18, no. 2, pp. 101–110, 2022.
[58] R. Al-Msie’deen, A. H. Blasi, and M. A. Alsuwaiket, “Constructing
a software requirements specification and design for electronic IT
news magazine system,” International Journal of Advanced and
Applied Sciences, vol. 8, no. 11, pp. 104–118, 2021.
[59] R. A. A. Al-Msie’deen, “A requirement model of local news we-
b/wap application for rural communities,” Master’s thesis, Universiti
Utara Malaysia, Utara, Malaysian, 2008.
[60] R. Al-Msie’deen, “Requirements traceability: Recovering and visu-
alizing traceability links between requirements and source code of
object-oriented software systems,” International Journal of Comput-
ing and Digital Systems, vol. 14, no. 1, pp. 1–17, 2023.
[61] H. E. Salman, A. Seriai, C. Dony, and R. Al-Msie’deen,
“Recovering traceability links between feature models and source
code of product variants,” in Proceedings of the VARiability
for You Workshop - Variability Modeling Made Useful for
Everyone, VARY ’12, Innsbruck, Austria, September 30, 2012,
Ø. Haugen, J. Jézéquel, A. Wasowski, B. Møller-Pedersen, and
K. Czarnecki, Eds. ACM, 2012, pp. 21–25. [Online]. Available:
[62] R. A. Al-Msie’deen and A. H. Blasi, “Software evolution un-
derstanding: Automatic extraction of software identifiers map for
object-oriented software systems,” Journal of Communications Soft-
ware and Systems, vol. 17, no. 1, pp. 20–28, 2021.
[63] R. A. Al-Msie’deen and A. Blasi, “Supporting software documen-
tation with source code summarization,” International Journal of
Advanced and Applied Sciences, vol. 6, no. 1, pp. 59–67, 2019.
[64] R. Al-Msie’deen, Object-oriented Software Documentation. Lap
Lambert Academic Publishing, 2019, iSBN: 9786200477279.
[65] R. A. Al-Msie’deen, “Automatic labeling of the object-oriented
source code: The lotus approach,” Science International-Lahore,
vol. 30, no. 1, pp. 45–48, 2018.
[66] R. Pawlak, M. Monperrus, N. Petitprez, C. Noguera, and
L. Seinturier, “SPOON: A library for implementing analyses

and transformations of java source code,” Softw. Pract. Exp.,
vol. 46, no. 9, pp. 1155–1179, 2016. [Online]. Available:
https://doi.org/10.1002/spe.2346
[67] M. L. Collard, M. J. Decker, and J. I. Maletic, “SrcML: An
infrastructure for the exploration, analysis, and manipulation of
source code: A tool demonstration,” in 2013 IEEE International
Conference on Software Maintenance, Eindhoven, The Netherlands,
September 22-28, 2013. IEEE Computer Society, 2013, pp. 516–
519. [Online]. Available: https://doi.org/10.1109/ICSM.2013.85
[68] R. Francese, M. Risi, G. Scanniello, and G. Tortora, “Proposing and
assessing a software visualization approach based on polymetric
views,” J. Vis. Lang. Comput., vol. 34-35, pp. 11–24, 2016.
[Online]. Available: https://doi.org/10.1016/j.jvlc.2016.05.001
[69] U. Erra and G. Scanniello, “Towards the visualization of
software systems as 3d forests: the codetrees environment,” in
Proceedings of the ACM Symposium on Applied Computing, SAC
2012, Riva, Trento, Italy, March 26-30, 2012, S. Ossowski and
P. Lecca, Eds. ACM, 2012, pp. 981–988. [Online]. Available:
[70] M. Lanza and S. Ducasse, “Polymetric views - A lightweight
visual approach to reverse engineering,” IEEE Trans. Software
Eng., vol. 29, no. 9, pp. 782–795, 2003. [Online]. Available:
https://doi.org/10.1109/TSE.2003.1232284
[71] L. Linsbauer, S. Fischer, G. K. Michelon, W. K. G. Assunção,
P. Grünbacher, R. E. Lopez-Herrejon, and A. Egyed, “Systematic
software reuse with automated extraction and composition
for clone-and-own,” in Handbook of Re-Engineering Software
Intensive Systems into Software Product Lines, R. E. Lopez-
Herrejon, J. Martinez, W. K. G. Assunção, T. Ziadi, M. Acher,
and S. R. Vergilio, Eds. Springer International Publishing,
2023, pp. 379–404. [Online]. Available: https://doi.org/10.1007/
978-3-031-11686-5 15
[72] O. Nierstrasz, S. Ducasse, and T. Gı̂rba, “The story of moose:
an agile reengineering environment,” in Proceedings of the 10th
European Software Engineering Conference held jointly with
13th ACM SIGSOFT International Symposium on Foundations
of Software Engineering, 2005, Lisbon, Portugal, September 5-9,
2005, M. Wermelinger and H. C. Gall, Eds. ACM, 2005, pp. 1–10.
[73] A. Bergel, Agile Visualization. LULU Press, 2016.
[74] D. M. Lyons, A. M. Bogar, and D. Baird, “Lightweight multilingual
software analysis,” in Proceedings of the 12th International
Conference on Software Technologies, ICSOFT 2017, Madrid,
Spain, July 24-26, 2017, J. Cardoso, L. A. Maciaszek, M. van
Sinderen, and E. Cabello, Eds. SciTePress, 2017, pp. 201–207.
[Online]. Available: https://doi.org/10.5220/0006392502010207
[75] R. Al-Msie’deen, A. Seriai, and M. Huchard, Reengineering Soft-
ware Product Variants Into Software Product Line: REVPLINE
Approach. LAP LAMBERT Academic Publishing, 2014.
[76] R. Al-Msie’deen, A. H. Blasi, H. E. Salman, S. S. Alja’afreh,
A. Abadleh, M. A. Alsuwaiket, A. Hammouri, A. J. Al Nawaiseh,
W. Tarawneh, and S. A. Al-Showarah, “Detecting commonality and
variability in use-case diagram variants,” Journal of Theoretical and
Applied Information Technology, vol. 100, no. 4, pp. 1113–1126,
2022.
[77] D. Kang, T. Kang, and J. Jang, “Papers with code or
without code? impact of github repository usability on the
diffusion of machine learning research,” Inf. Process. Manag.,
vol. 60, no. 6, p. 103477, 2023. [Online]. Available: https:
//doi.org/10.1016/j.ipm.2023.103477
[78] L. P. Tizzei, M. O. Dias, C. M. F. Rubira, A. Garcia, and J. Lee,
“Components meet aspects: Assessing design stability of a software
product line,” Inf. Softw. Technol., vol. 53, no. 2, pp. 121–136, 2011.
[Online]. Available: https://doi.org/10.1016/j.infsof.2010.08.007
[79] E. Figueiredo. (2011) MobileMedia - java implementation.
[Online]. Available: https://homepages.dcc.ufmg.br/∼figueiredo/spl/
icse08/ (Accessed: Nov. 18, 2024).
[80] R. A. Al-Msie’deen, “BushraDBR: An automatic approach to re-
trieving duplicate bug reports,” International Journal of Computing
and Digital Systems, vol. 15, no. 1, pp. 221–238, 2024.
[81] T. Paiva, A. Damasceno, E. Figueiredo, and C. Sant’Anna,
“On the evaluation of code smells and detection tools,” J.
Softw. Eng. Res. Dev., vol. 5, p. 7, 2017. [Online]. Available:
https://doi.org/10.1186/s40411-017-0041-1
[82] Mozilla-rhino. (2023) Rhino: JavaScript in Java - Version
1.7R2. [Online]. Available: https://github.com/mozilla/rhino#
rhino-javascript-in-java (Accessed: Nov. 18, 2024).
[83] R. A. F. Moreira, W. K. G. Assunção, J. Martinez, and
E. Figueiredo, “Open-source software product line extraction
processes: the argouml-spl and phaser cases,” Empir. Softw.
Eng., vol. 27, no. 4, p. 85, 2022. [Online]. Available: https:
//doi.org/10.1007/s10664-021-10104-3
[84] R. Al-Msie’deen. (2018) Drawing shapes software. [Online]. Avail-
able: https://sites.google.com/site/ralmsideen/tools (Accessed: Nov.
18, 2024).
[85] Health-Watcher. (2023) Health watcher software - Version 10. [On-
line]. Available: https://ptolemy.cs.iastate.edu/design-study/ (Ac-
cessed: Nov. 18, 2024).
[86] ArgoUML. (2010) ArgoUML software. [Online]. Available: https:
//argouml-tigris-org.github.io/tigris/argouml/ (Accessed: Nov. 18,
2024).
[87] A. M. Davis, 201 principles of software development. McGraw-
Hill, 1995.
[88] J. Hunter. (2000) JDOM. [Online]. Available: https://github.com/
hunterhacker/jdom/ (Accessed: Nov. 18, 2024).
[89] AT&T-Labs-Research. (1991) Graphviz. [Online]. Available: https:
//graphviz.org/ (Accessed: Nov. 18, 2024).
[90] S. A. Butt, M. Acosta-Coll, and S. Misra, “Software product
maintenance: A case study,” in Computer Information Systems and
Industrial Management - 21st International Conference, CISIM
2022, Barranquilla, Colombia, July 15-17, 2022, Proceedings, ser.
Lecture Notes in Computer Science, K. Saeed and J. Dvorský,
Eds., vol. 13293. Springer, 2022, pp. 81–92. [Online]. Available:
https://doi.org/10.1007/978-3-031-10539-5 6

ScaMaha: A Tool for Parsing, Analyzing, and Visualizing Object-Oriented Software Systems

More Related Content

Similar to ScaMaha: A Tool for Parsing, Analyzing, and Visualizing Object-Oriented Software Systems (20)

More from Ra'Fat Al-Msie'deen (20)

Recently uploaded (20)

ScaMaha: A Tool for Parsing, Analyzing, and Visualizing Object-Oriented Software Systems