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

ScaMaha:
A Tool for Parsing, Analyzing, and
Visualizing Object-Oriented Software
Systems
Dr. Ra'Fat Al-Msie'deen
Department of Software Engineering, Faculty of IT, Mutah University,
Mutah 61710, Karak, Jordan
rafatalmsiedeen@mutah.edu.jo
https://rafat66.github.io/Al-Msie-Deen/

➢ To cite this version:
R. Al-Msie’deen, “ScaMaha: A Tool for Parsing, Analyzing, and
Visualizing Object-Oriented Software Systems,” International Journal of
Computing and Digital Systems, vol. 17, no. 1, pp. 1-20, 2025.
• URL:
https://www.researchgate.net/publication/386985118_ScaMaha_A_Tool_for_
Parsing_Analyzing_and_Visualizing_Object-Oriented_Software_Systems

ScaMaha:
A Tool for Parsing, Analyzing, and Visualizing Object-Oriented
Software Systems
❖ ScaMaha is a tool for parsing, analyzing, and visualizing OO software systems.
❖ Keywords: Software engineering, Reverse engineering, Software re-engineering, Object-
Oriented source code, Static code analysis, Software visualization, Software metrics,
ScaMaha tool.
❖ ScaMaha tutorial:
▪ https://drive.google.com/drive/folders/11_CItJ2pPq_1CAWswcjRsAZnhmQO6OQ8
❖ ScaMaha: @github
▪ https://github.com/rafat66/ScaMaha

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.

Abstract …
• 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.

Abstract …
• 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, like precision and recall, demonstrate the accuracy
of ScaMaha in parsing, analyzing, and visualizing software source code,
as all code artifacts (i.e., code file, software metrics file, and code
visualizations) were correctly extracted.

Introduction and Overview
• 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 visualization. Thus, these
tools should adapt to a wide range of cases.
• 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.
• This paper presents ScaMaha tool, which is a reverse engineering tool for
performing software analysis and visualization.
• 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 infrastructure of ScaMaha tool.

Repository
(aka. code
database)
Visualizer Other tools
Parser
Meta-model
Software source code
Corresponds to
Analyzer
Attribute
Method
Package
Class
Belongs to
Package
1..*
Belongs to Class
0..*
0..*
1 1
“Typical infrastructure for re-engineering tools”

Precision
F-measure
Recall
Software source code
Software code metrics file
OUTPUT Code visualizations
CASE STUDY
Drawing shapes software
Mobile photo software
Health watcher software
Rhino software
ArgoUML software
Static code analysis
MAIN ELEMENTS
Code visualizer
Code parser
Code analyzer
TYPE OF CODE ANALYSIS
EVALUATION METRICS
Code file
“The main elements of
ScaMaha approach.”

Use of Code Parser, Analyzer, and Visualizer in this Work
Software
Source Code
Input
ScaMaha
Code Parser
Parsed Code
(Metadata – i.e., an XML file)
Output
Code
Database
ScaMaha
Code Analyzer
Analyzed Code
E.g., Software Metrics
Output
ScaMaha
Database
ScaMaha Code
Visualizer
Visualized Code
E.g., Inheritance Relations
(Metadata – i.e., DOT file)
Output
An overview of
ScaMaha tool

“Software
engineer”
Browse and import
software code from
the workspace
Run the
ScaMaha tool
Parse software code
using the ScaMaha
parser
Calculate software
code metrics using
the ScaMaha analyzer
Visualize software
code using the
ScaMaha visualizer
Exit the ScaMaha
tool
ScaMaha tool
The use-case
diagram of
ScaMaha tool.

Related Work
• ScaMaha* is a reverse engineering tool for parsing, analyzing, and visualizing
• Moose is a well-known reverse engineering tool [1]. It began as a research
project around 24 years ago.
• MODMOOSE is the new version of Moose [2]. Tool developers can develop
specialized reverse engineering tools with MODMOOSE. Moose was based on the
Famix metamodel [3].
[ScaMaha] https://github.com/rafat66/ScaMaha
[1] 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. [Online]. Available: https://doi.org/10.1145/1081706.1081707
[2] 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.
https://link.springer.com/chapter/10.1007/978-3-030-64694-3_8
[3] 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: Feb. 5,
2024).

Related Work ... [continued]
• Bruneliere et al. [4] suggested a semantic and syntax analysis-based
parser for the creation of AST and metrics for multi-language
software systems. Their meta-modeling tool [5] is utilized to analyze
multi-language applications [6].
[4] 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
[5] H. Bruneliere. (2010) MoDisco. [Online]. Available: https://www.eclipse.org/MoDisco/ (Accessed: Feb. 5, 2024).
[6] H. Bruneliere, J. Cabot, G. Dup´e, 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

• VerveineJ is a parser developed in Java that constructs an MSE file from
software source code [7].
• Wettel and Lanza [8] 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 [9].
[7] Moose VerveineJ. (2023) VerveineJ. [Online]. Available: https://modularmoose.org/moose-
wiki/Developers/Parsers/VerveineJ.html (Accessed: Feb. 5, 2024).
[8] 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. IEEE Computer Society, 2007, pp. 92–99. [Online].
Available: https://doi.org/10.1109/VISSOF.2007.4290706
[9] D. Moreno-Lumbreras, R. Minelli, A. Villaverde, J. M. Gonz´alez-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

• 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 [10], SrcML [11], and
SuperParser [12].
[10] 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
[11] 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
[12] 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

• The methods of software source code visualization have become increasingly
utilized to support software engineers in software understanding. In software
visualization, some methods aim at displaying software source code in a
recognized environment, like a forest [13] or a city.
• Another method is to generate what is called a polymetric view [14], described as
a lightweight visualization technique supplemented with several metrics
regarding software code.
• ScaMaha visualizes different aspects of software source code, such as code
organization and relations.
[13] 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: https://doi.org/10.1145/2245276.2245467
[14] 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

• Lyons et al. [15] have suggested the lightweight multilingual 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 the ScaMaha tool uses only one code parser for the Java
language.
[15] 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

Browse and Select OO Software Systems
Parse Software Code with ScaMaha Parser
Code File
OO Source Code (e.g., Java and C++)
Perform Code Analysis &
Extract Code Metrics Via
ScaMaha Analyzer
select
parse
export
import
E.g., Software Metrics File E.g., Code Visualization
Visualize Software
Code Via ScaMaha
Visualizer
Code Identifiers
Code Relations
Code Meta-model
Static Code Analysis
Analyzing and visualizing OO
source code with ScaMaha tool

The core of ScaMaha meta-model
• ScaMaha operates on a model of software source code, namely
ScaMaha model.
• To analyze the OO software system, you must first create a model of it
using ScaMaha.
• Figure “The core of ScaMaha meta-model” 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) between them.

Name
Attribute
Name
Method
Method Invocation
Name
Parameter
Attribute Access
Accessed In
Has a
Software Product
Source Code
Name
Release
Name
Package
1..*
Name
Class
Belongs to
Package
1..*
Belongs to
Class
Text
Comment
0..*
0..*
0..*
Text
Comment
0..*
Name
Local Variable
Belongs to
Method
0..*
0..*
Has accesses
Has Candidates
0..*
1
0..*
0..*
Invoked
by
1
1
1 0..*
1
1
Inheritance
Has
superclass
1 0..*
1 Subclass
The core of
ScaMaha
meta-model.

ScaMaha tool - An overview of the core parts of the ScaMaha tool
Output
Code visualization
E.g., Inheritance Relations
(Metadata – i.e., png, svg, pdf)
Output
Code file
Data
Importer
Input
Software Source Code
Exporter
Output
Software metrics file
“ScaMaha tool”
Code Parser
Code Analyzer
Code Visualizer
Code meta-model
An overview of the
core parts of
ScaMaha tool.

Browse and Select Java Software
Parse Java Code with ScaMaha Parser
XML File
Java Source Code
export
parse
import
select
Source Code
load
Visualize Software
Code
Software code as an
XML file “code file”
Extract Main
Software Metrics
Software metrics
as an XML file
Code graphs (png,
svg, pdf, etc.)
Load ScaMaha Model of Java Source Code
ScaMaha Analyzer ScaMaha Visualizer
The Java
implementation of
ScaMaha tool.

XML format corresponding to ScaMaha meta-model
• In this work, XML is a generic file format that represents 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 “XML format corresponding to ScaMaha meta-model” shows
the XML format corresponding to ScaMaha meta-model.

XML format
corresponding to ScaMaha
meta-model.

The code file of
mobile photo
software as an XML
file (partial) [16].

Software code metrics of ScaMaha code analyzer

Software code metrics for Rhino software

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 implementation 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

▪ 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 dependencies between classes and methods.
▪ In addition, ScaMaha visualizer gives a polymetric view of software
based on its packages.
▪ Additionally, ScaMaha Visualizer generates tag clouds derived from
software source code, specifically from software identifiers.
▪ 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.

An architectural view of ScaMaha
tool in a simplified structure.

<< Component >>
ScaMaha Parser
[Static Code Analysis]
<< Java Source Code >>
[Software Product]
<< Code File >>
[ScaMaha Meta-model,
XML File]
uses
produces
<< Component >>
ScaMaha Analyzer
uses
<< Software Metrics File >>
[XML File - Metadata]
<< Component >>
ScaMaha
<< Component >>
JDOM Library
uses
<< Component >>
ScaMaha Visualizer
uses
<< Component >>
Graphviz Library
produces
uses
uses
<< DOT File >>
[Graph Description Language]
produces
uses
<< Graph Visualization >>
[SVG, PNG, PDF, or GIF File]
produces
Software
source code
Metrics File
Code Graphs
Source Code
Code File
Dot File
<< Code File >>
[ScaMaha Meta-model,
XML File]
Code file,
metrics file, and
code graphs
uses produces

Visualization of method invocation relations
for mobile photo software (partial).

Visualization of class inheritance
relations for mobile photo software
(partial).

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.

Code organization visualization of
mobile photo software (partial)

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.

Visualization of class
inheritance relations for
drawing shapes software.

Tag cloud extracted from the
drawing shapes software using
ScaMaha.
The figure above shows a tag cloud generated from the source code of the drawing shapes
software using ScaMaha. It highlights key software identifiers, including package names,
class names, attribute names, and method names. Larger tags represent higher frequency
and importance, with tag frequencies displayed in red within square brackets.

The code file of drawing shapes
software as an XML file (partial) [16].

Conclusion
• This paper has presented ScaMaha, a tool for parsing, 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.

Conclusion …
• 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.

Future Work
• 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 conduct 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
[16] R. A. A. Al-Msie’deen. (2023) ScaMaha. [Online]. Available:
https://drive.google.com/drive/folders/11_CItJ2pPq_1CAWswcjRsAZnhmQO6OQ8
(Accessed: Feb. 5, 2024).

A Tool for Parsing,
Analyzing, and
Visualizing Object-
Oriented Software
Systems
ScaMaha tool
Dr. Ra'Fat Al-Msie'deen

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