Gordana Rakic

A language-independent approach to the extraction of dependencies between source code entities

Context: Software networks are directed graphs of static dependencies between source code entities (functions, classes, modules, etc.). These structures can be used to investigate the complexity and evolution of large-scale software systems and to compute metrics associated with software design. The extraction of software networks is also the first step in reverse engineering activities. Objective: The aim of this paper is to present SNEIPL, a novel approach to the extraction of software networks that is based on a language-independent, enriched concrete syntax tree representation of the source code. Method: The applicability of the approach is demonstrated by the extraction of software networks representing real-world, medium to large software systems written in different languages which belong to different programming paradigms. To investigate the completeness and correctness of the approach, class collaboration networks (CCNs) extracted from real-world Java software systems are compared to CCNs obtained by other tools. Namely, we used Dependency Finder which extracts entity-level dependencies from Java bytecode, and Doxygen which realizes language-independent fuzzy parsing approach to dependency extraction. We also compared SNEIPL to fact extractors present in language-independent reverse engineering tools. Results: Our approach to dependency extraction is validated on six real-world medium to large-scale software systems written in Java, Modula-2, and Delphi. The results of the comparative analysis involving ten Java software systems show that the networks formed by SNEIPL are highly similar to those formed by Dependency Finder and more precise than the comparable networks formed with the help of Doxygen. Regarding the comparison with language-independent reverse engineering tools, SNEIPL provides both language-independent extraction and representation of fact bases. Conclusion: SNEIPL is a language-independent extractor of software networks and consequently enables language-independent network-based analysis of software systems, computation of design software metrics, and extraction of fact bases for reverse engineering activities.

Language independent framework for static code analysis

The aim of this paper is to describe a framework consisting of a set of static analyzers. The main characteristic of all incorporated tools is their independency of input programming language. This independency is based on a universal representation of the source code that is to be analyzed. The overall goal of this research is to provide a framework that is suitable for consistent analysis of the source code with the intention to ensure, check, and consequently increase the quality of the heterogeneous software products. The framework currently integrates three tools: software metrics tool -- SMIILE, extractor of software networks -- SNEIPL and structure change analyzer -- SSCA, with tendency to extend this set of components. Further application of these tools in collaboration with other tools on higher level provides even broader applicability of described framework.

Extractor of software networks from enriched concrete syntax trees

Software networks are directed graphs of dependencies among entities (packages, classes, methods, etc.) found in a software system. These structures are used to study organizational software complexity and evolution. In this paper the prototype of software networks extractor - SNEIPL is described. SNEIPL uses enriched concrete syntax tree (eCST) representation of a source code. The benefit of such representation is that it enables independency of programming language. First experiences using SNEIPL showed that it correctly extracted isomorphic software networks from the source code of two structurally and semantically equivalent programs written in different programming languages.

SSQSA architecture

The aim of this paper is to describe architecture of the software system called Set of Software Quality Static Analyzers (SSQSA). The main aim of SSQSA is to provide some static software analyzers to ensure, check, and consequently increase, the quality of software products. Its main characteristic is the language independency which makes it more usable than many other similar systems.

A programming language independent framework for metrics-based software evolution and analysis

Knowledge about different aspects of software quality during software evolution can be valuable information for developers and project managers. It helps to reduce the number of defects and improves the internal structure of software. However, determining software’s quality and structure in heterogeneous systems is a difficult task. In this paper, a programming language independent framework for evaluating software metrics and analyzing software structure during software development and its evolution will be presented. The framework consists of the SMIILE tool for calculation of software metrics, extended with an analysis of software structure. The data are stored in a central repository via enriched Concrete Syntax Tree (eCST) for universal source code representation. The framework is demonstrated in a case study. The development of such a framework is a step forward to consistent support for software evolution by providing a change analysis and quality control. The significance of this consistency is growing today, when software projects are more complex, consisting of components developed in diverse programming languages.[Acknowledgments. Work of the second and third author is partially supported by the Serbian Ministry of Science and Technological Development through project no. OI174023 ”Intelligent Techniques and Their Integration into Wide-Spectrum Decision Support”. Bilateral project between Slovenian Research Agency and Serbian Ministry of Science and Technological Development (Grant BI-SR/10-11-027) enabled the exchange of visits and ideas between authors of this paper and their institutions.]

XML‐Based Integration of the SMIILE Tool Prototype and Software Metrics Repository

An adequate system for collecting and analyzing software metric results is crucial for the successful interpretation of software characteristics during the software development process. Furthermore, the right interpretation can also identify poor quality in complex modules within software systems. However, there is a gap between raw metrics data and the right interpretation of them. In this paper, the integration of a language independent metric tool (SMIILE prototype [9]) for metrics data extraction and the software metrics repository for storing and analyzing extracted data will be described. With this integration we hope to overcome some of the difficulties that application of sofware metrics experienced in practice.

Translation of Tempura specifications to eCST

eCST is an innovative, language-independent intermediate source code representation designed as a basis of approach applied in development of SSQSA framework. This framework provides an infrastructure for consistent static software analysis. Tempura is a formal specification language, while Tempura programs are executable ITL (Interval Temporal Logic) specifications. This paper describes required steps to enable generation of eCST representation of Tempura code which leads to an incorporation of Tempura language in the infrastructure of SSQSA framework. This incorporation serves as a proof of concept that a formal specification language (like Tempura) can be successfully represented with an intermediate language representation (like eCST) that was primarily aimed for representation of “classical” programming languages.

Consistent Static Analysis in Multilingual Software Products Development

The paper points out some problems that are existing in the field of static analysis of software quality. Building tools that are language independent and based on a common intermediate structure are seen as a way to overcome most of the observed problems. As an example, an original, language-independent infrastructure containing a set of static quality software analyzers (SSQSA) is introduced.

eCST to source code generation - an idea and perspectives

eCST (enriched Concrete Syntax Tree) is introduced as a fundament of SSQSA (Set of Software Quality Static Analyzers) platform for consistent static quality analysis across the input languages. It is based on the concept of enrichment of the complete syntax tree representing the input program by universal nodes. Universal nodes are based on the idea of imaginary nodes in an abstract syntax tree, but unified, so that one single node is used for all languages where it is applicable. In this paper, we describe a translation of eCST back to source code. At this moment, this is only translation to the original language in which code is written. Moreover, the translation of eCST to a code written in the original language can have a wide spectre of applications such as in (semi-)automated code refactoring and transformations.

Towards the XML schema measurement based on mapping between XML and OO domain

Measuring quality of IT solutions is a priority in software engineering. Although numerous metrics for measuring object-oriented code already exist, measuring quality of UML models or XML Schemas is still developing. One of the research questions in the overall research leaded by ideas described in this paper is whether we can apply already defined object-oriented design metrics on XML schemas based on predefined mappings. In this paper, basic ideas for mentioned mapping are presented. This mapping is prerequisite for setting the future approach to XML schema quality measuring with object-oriented metrics.