Researchers of LLP UFMG::DCC::LLP - Programing Language Laboratory


Current Research Projects



A Hybrid Approach to Change Impact Analysis in Object-Oriented Systems

Abstract. The modification of software artifacts to insert new functionalities or correct errors is inherent to the software life cycle. Only through it can a software system continue to meet the user's needs. However, making a software modification may be a challenging task. When changing a software artifact, a developer must analyze the impact this modification will have on other artifacts and, if necessary, modify them so that the software system remains consistent. This analysis is called Change Impact Analysis (CIA). Some methods for change impact analysis, particularly for class-level, have been proposed over the years. However, these methods fail to be impractical for the day-to-day developer since they are very complex methods. Therefore, analyzing the impact that modifying a class has on a software system is still a challenge to overcome. Hence, this research aims to define a new class-level CIA method for object-oriented software. To base our proposal, we will conduct the following studies: (i) investigate the state of the development practice, seeking to identify developers'level of knowledge and application of software maintenance concepts; (ii) investigate the state-of-art through a systematic mapping review (SMR) on change impact analysis; (iii) conduct an empirical study to characterize commits in open-source systems developed in Java. Based on the results of these empirical studies, we will propose a new commit-based heuristic for the CIA, aiming to overcome the main fragilities of the commit-based approaches previously proposed in the literature. Besides, we intent to compare the proposed heuristic with some of the commit-based approach for CIA previously proposed in the literature. We will base this analysis on data from 237,366 commits from 38 Java open-source software systems. We hypothesize that the exclusive use of commits to the CIA is not an accurate approach. Therefore, we also hypothesize that the data extracted from the software dependency graph should be also considered in CIA. Hence, we propose to use a weighted dependency graph to estimate the impact of modifying a class in object-oriented systems. The weights applied in the dependency graph will be defined both in historical commits data and the software system's static characteristics.


Modeling and Predicting Evolution of Software Quality Internal Attributes

Abstract. Software evolution is a natural process of the software life cycle. It consists of adapting, maintaining, and updating software systems. This research will concentrate on investigating how software systems evolve along time. Many studies have been carried out on this topic. However, we do not have a general view of the state-of-the-art of software evolution research. To start, our first step was to conduct a comprehensive Systematic Literature Review (SLR) to compile the body of knowledge on software evolution and understand how the literature investigated this topic. Our SLR analysis revealed that software evolution has been studied from five perspectives: (i) verification of the applicability of Lehman's laws; (ii) proposal of applications, (iii) analysis of the evolution with a focus on quality, (iv) analysis of the software structure evolution, and (v) proposal of models for software evolution. Besides, the studies on software engineering have confirmed that as software systems evolve, it becomes increasingly complex and challenging to maintain. Nevertheless, the studies carried out so far have not detailed how such degradation occurs. Understanding how the internal software structure evolves is essential to help developers to better plan, manage, and perform software maintenance tasks. This research aims to provide a fine-grained knowledge of how the internal structure of object-oriented software systems evolves. To do that, we will consider three internal characteristics of these software systems: coupling, size of classes, and inheritance hierarchy. We intent to define a novel method based on time series analysis, linear regression techniques, and trend tests to analyze the evolution of object-oriented systems. Applying such an approach, we hope to identify the function that better explains how the coupling, classes' size, and the inheritance tree evolve. To assess these characteristics, we will use software metrics defined in the literature and consider data from ten Java-based open-source projects. In the sequel of this research, we aim to define and evaluate a prediction method for object-oriented software evolution in terms of coupling, size of classes, and inheritance hierarchy. We will base the method on the results found in the first part of this research. We will construct an automatic approach to identify a prediction model for a given system. Our method's entry will be a set of metric time series, and the result of the method will be a model that predicts how the software system will evolve in terms of the attributes the metrics measure. To evaluate the proposed method, we will extend a previous data set used in the literature. In real software engineering scenarios, the results of the proposed research may support developers to plan their strategies to accommodate changes and novel features in the system, so that the software architecture degradation may be mitigated or avoided.


Recent Years Former Research Projects



The Nature Evolving of Bad Smells in Object Oriented Software -- A Empirical Study Applying Threshold to Software Metrics

Abstract. There are in the literature several studies investigating the relevance of bad smells regarding the evaluation of the code quality. Although bad smell is considered an indicator of a possible problem and is directly connected with the quality of the software, there is still no consensus among researchers of the area in relation when the bad smells are inserted in the code. It was considered until now that maintenance activities and evolution of software are responsible for frequent cause of inclusion of bad smells in the systems. However, recent studies contradict this statement, presenting results to demonstrate that the majority of bad smells are introduced in the code when the software is created. The main objective of this research is to conduct an empirical study regarding the application of threshold for metrics of object oriented software to analize the evolving nature of bad smells, investigating when bad smells are introduced into software in order to describe the software evolutionary patterns from the point of view of bad smells based on the results observed in this empirical study.



Design Patterns and Bad Smell: A Study Evaluative Applying Software Metrics

Abstract. The software development process needs to be well planned. Poorly designed software can present problems in its structure or code, thus hampering their reuse and future maintenance. These problems in the structure or software code are called bad smell. Design patterns are reusable solutions to general problems that occur frequently within a software project. When applying a design pattern in the software development process, it is expected to achieve a reusable structure without the presence of bad smells. Based on this, the aim of this research is to apply metrics to identify bad smells in software developed with design patterns. The purpose of such evaluation is to investigate how design pattern aid to avoid bad smell, as well as in which situations software systems with design patterns have bad smells. Preliminary analyses were performed with five softwares, considering two bad smells: Long Method and God Class. The results of this study suggest that the use of design patterns does not eliminate the occurrence of bad smells in practice.



The Usefulness of Software Metrics with their Related Threshold to Assure the Quality of Object Oriented Software

Abstract. Problems in software quality are generally identified by testing and inspections, techniques in which maintenance efforts are concentrated mainly in the fault correction and in the addition of new features. However, these activities require time and generate costs. Software metrics can be an effective measurement tool to assess the quality of software and to aid making decisions, by pointing out improvements needs in the software systems. But to carry out an effective measurement, it is essential to define significant thresholds for the software metrics. The use of thresholds associated with metrics creates an alternative to identify failures and detecting project deviations, known in the literature as bad smells, in object oriented software. The aim of this research is to conduct an empirical study in order to investigate the usefulness of software metrics thresholds to predict software failures and to detect bad smells. Specifically, we aim to advance in the state of the art by analyzing a great number of metrics with threshold in order to understand and establish possible relations between reference values of metrics, failures and bad smells with respect to software quality.
Priscila Pereira, Mariza A.S.Bigonha, Kecia Ferreira



Automatic Inference of Loop Complexity through Polynomial Interpolation

Abstract. In this project we present two static analyses for inference of array sizes, as well as an algorithm for generation of test cases capable of generating safe tests by using such analyses. In order to evaluate the efectiveness of our technique, we performed two experiments. In the first of them, we found that the static analyses were able to relate 34.6% of the array sizes received as parameter by functions of the programs of the SPEC CPU 2006 benchmark suite, which contains real world programs. In the second, we used Asymptus, a tool for automatic inference of function complexity which was developed during this research as a preliminary work, over the test cases generated by our technique. Asymptus was able to correctly infer the complexity of functions both written by us and extracted from the Polybench benchmark suite. It shows that our technique of input generation is useful for the automatic execution of interest functions.
Junio Cezar, Francisco Demontiê, Mariza A. S. Bigonha e Fernando Pereira.


A Transparent Memory Model Scratchpad for Architectures of General Purpose

Abstract. Scratchpad memories are largely used in embedded architectures, but traditionally in general-purpose projects cache benefits and the legacy code make it unpractical. Manual memory management provides real-time guarantees and allows more efficient choices for data allocation, allowing to reach a best performance for some classes of algorithms. The transparent caches provide a mixed approach to data management on the fastest level of the memory hierarchy. In this project a study is conducted to evaluate the behavior of a general purpose architecture using an ARM9 simulator provided with a transparent cache. In these experiments an improvement up to 30% was observed with an increasing in the compiler generated code size in average by 102%. Transparent caches are a solution to reconcile the backward compatibility demands in a transparent way, produce more compatible applications between different architectures and make possible to meet different requirements for build more efficient solutions.
Felipe Silva Loredo, Mariza Andrade da Silva Bigonha, Claudionor José Nunes Coelho Junior


Identification of Thresholds for Object-Oriented Software Metrics

Abstract. In this project, we applied a predefined empirical method to an 111 system dataset, identifying thresholds for 18 object-oriented software metrics. Furthermore, we proposed some improvements in that method. Differently from previous work, we have defined a catalogue of thresholds that gathers a greater amount of object-oriented software metrics, allowing the assessment of methods, classes and packages. Our approach suggests three ranges in the thresholds: Good/Common, Regular/Casual and Bad/Uncommon. The Good/- Common range corresponds to values with high frequency. The Bad/Uncommon range corresponds to values with quite low frequency, and the Regular/Casual range is an intermediate one, which corresponds to values that are not too frequent neither have very low frequency. Although they do not necessarily express the best practices in Software Engineering, they reflect a quality standard followed by most of the evaluated software. To evaluate the effectiveness of the defined thresholds to indicate the real panorama of the software quality, we conducted three case studies and an experiment. The results suggest that the thresholds proposed can indicate the quality of the software, providing a benchmark for the quantitative assessment of the internal quality of object-oriented software, considering methods, classes and packages. We also developed a tool called RafTool.
Tarcísio Filó, Mariza A. S. Bigonha, Kecia Ferreira


Mining Architectural Violations from Version History

Abstract. In this project we developed a tool ArchLint that detects absences and differences present in the source code systems oriented by objects. Software architecture conformance is a key software quality control activity that aims to reveal the progressive gap normally observed between concrete and planned software architectures. However, formally specifying software architectures is not a trivial task, as it must be done by an expert on the system under analysis. In this project, we investigate an approach for architecture conformance based on a combination of static and historical source code analysis. The proposed approach relies on four heuristics for detecting both (1) absences, something expected was not found, and (2) divergences, something prohibited was found, in source code based architectures. We also present an architecture conformance process based on the proposed approach. We followed this process to evaluate the architecture of two industrial-strength information systems, for which were detected 539 architectural violations, with an overall precision of 62.7% and 53.8%. We also evaluated our approach in two open-source systems, for which were detected 345 architectural violations, achieving an overall precision of 53.3% and 59.2%. The proposed approach uses the detected architectural patterns to select absences and divergences in the source code. We evaluated the proposed approach in an industrial strength information system, and we found 137 architectural violations, with an overall precision of 41.2%.
Cristiano Maffort, Marco Túlio O. Valente, Mariza Bigonha.


Bad Smells Detection in Software from UML Models

Abstract. The objective of this project is to propose a method and a tool for identifying bad smells, using software metrics, in UML models. We carried out two experiments to evaluate the proposed method: the first one aimed to evaluate the results of our method when applied to old versions as well as to refactored versions of six open source projects; in the second experiment, we compare the results of our method with the results of manual inspections. The results of these experiments indicate that our method is able to identify the bad smells analyzed in this project. UMLSmells is a tool developed to identify bad smells, via software metrics, in objects oriented systems from UML models.
Henrique N. Gomes, Flávio Madureira, Mariza A. S. Bigonha, Kecia Ferreira.


K3B: A Model for Estimating Change Propagation in Software

Abstract. In this project we propose a novel model, named K3B, for estimating change propagation impact in a software system. The model aims to predict how far a set of changes will propagate throughout the system. K3B is a stochastic model that has as input parameters about the system and the number of modules which will be initially changed. K3B returns the estimated number of change steps, considering that a module may be changed more than once during a modication process. We provide the implementation of K3B for object-oriented programs. We compare our implementation with data from an artificial scenario, given by simulation, as well as with data from a real scenario, given by historical data. We found strong correlation between the results given by K3B and the results observed in the simulation, as well as with historical data of change propagation. K3B may be used for comparing software systems from the viewpoint of change impact. The model may aid software engineers in allocating proper resources to the maintenance tasks. This project is an evolution of another project called Connecta, where we developed a tool CONNECTA that analyzes bytecode files, collecting metrics assessment of cohesion, stability and connectivity programs in order to allow developers to build software with a higher degree of maintainability.
Kecia A. Marques Ferreira, Mariza A. S. Bigonha, Roberto S. Bigonha, Luiz Felipe O. Mendes, Heitor C. Almeida.

link

System CT

Abstract. System CT extends ML-style type inference for supporting overloading and polymorphic recursion. The simplicity of core-ML type inference is maintained, with no exception or special constructs included for coping with overloading. We have designed an overloading policy with which we can assure decidability of type inference for constrained polymorphism (i.e. parametric polymorphism and overloading) while not over restricting the set of possible overloaded definitions.


PeerSpaces Logo

The PeerSpaces Coordination Model

Abstract. PeerSpaces is a shared space coordination model designed for ad hoc mobile networks. The model is based on the concept of tuple spaces firstly proposed by Linda. In order to address the dynamic environment that characterizes ad hoc networks, PeerSpaces does not assume the presence of any centralized structure for communication and coordination. My contributions to the PeerSpaces project are related to the implementation of two different systems based on this architecture. The first of them is an implementation of the model to a fixed network environment and the other is an implementation of a simulator of distributed algorithms that use the coordination language proposed in the model.


Weed

The Language LinF for L-System Specification

Abstract. LinF is a programming language devised for L-System specifications. L-Systems are formal string rewriting systems introduced in 1968 by the botanist Aristid Lindenmayer, and are used to model fractal images. LinF allows the definition of three-dimensional and stochastic fractals. My main contributions to the LinF project are the specification of the language and the implementation of part of a interpreter called cflc. That is an OpenGL-based system that generates fractal images from LinF specifications. Results obtained through the LinF formalism show the ease of use and generality of the developed tools with respect to the existing literature.


Weed

Arcademis

Abstract. Arcademis is a framework for middleware development. Its main objective is to provide application developers with a tool that can be used in the design and implementation of middleware platforms. A framework is a set of inter-related components that can be assembled together and customized according to the programmer's necessities. In order to validate the proposed system, a remote method invocation service has been implementated from the framework's components. Such service targets the J2ME version of the Java language and allows the remote execution of methods in an environment where reflexity is not provided.


Weed

PSBib

Abstract. PSBib is prototype web system designed to perform strings pattern matching on PostScript files.


img

Last update: March, 20th, 2023.