Everton T. Guimarães

Prioritization of Code Anomalies Based on Architecture Sensitiveness

Code anomalies are symptoms of software maintainability problems, particularly harmful when contributing to architectural degradation. Despite the existence of many automated techniques for code anomaly detection, identifying the code anomalies that are more likely to cause architecture problems remains a challenging task. Even when there is tool support for detecting code anomalies, developers often invest a considerable amount of time refactoring those that are not related to architectural problems. In this paper we present and evaluate four different heuristics for helping developers to prioritize code anomalies, based on their potential contribution to the software architecture degradation. Those heuristics exploit different characteristics of a software project, such as change-density and error-density, for automatically ranking code elements that should be refactored more promptly according to their potential architectural relevance. Our evaluation revealed that software maintainers could benefit from the recommended rankings for identifying which code anomalies are harming architecture the most, helping them to invest their refactoring efforts into solving architecturally relevant problems.

Identifying Architectural Problems through Prioritization of Code Smells

Architectural problems constantly affect evolving software projects. When not properly addressed, those problems can hinder the longevity of a software system. Studies have revealed that a range of architectural problems are reflected in source code through two or more code smells. However, a software project often contains thousands of code smells and many of them have no relation to architectural problems. Thus, developers may feel discouraged to identify architectural problems if they are not equiped with means to focus their attention in a reduced set of locations in their system to start with. However, state-of-the-art techniques fall short in assisting developers in the prioritization of code smells that are likely to indicate architectural problems in a program. As a consequence, developers struggle to effectively focus on (groups of) smells that are architecturally relevant, i.e., smells that contribute to a critical design problem. This work presents and evaluates a suite of criteria for prioritizing groups of code smells as indicators of architectural problems in evolving systems. These criteria are supported by a tool called JSpIRIT. We have assessed the prioritization criteria in the context of more than 23 versions of 4 systems, analyzing their effectiveness for spoting locations of architectural problems in the source code. The results provide evidence that one of the proposed criteria helped to correctly prioritize more than 80 (locations of) architectural problems, alleviating tedious manual inspections of the source code vis-a-vis with the architecture. This prioritization criteria would have helped developers to discard at least 500 code smells having no relation to architectural problems in the analyzed systems.

Analysing the Impact of Feature Dependency Implementation on Product Line Stability: An Exploratory Study

The evolution of software product lines (SPLs) is particularly challenging. SPL functionalities, usually decomposed into features, naturally depend among them. As the SPL evolves, the implementation of each feature dependency might increasingly affect more code elements. Therefore, as the complexity of feature dependency implementation grows up through code evolution, it is likely to negatively impact on the SPL stability. Stability refers to the amount of changes between SPL releases and it is directly influenced by the complexity of feature dependency implementation. In this context, a number of emerging programming techniques can be used to keep the complexity of feature dependency code under control. Nevertheless, there is a lack of studies analysing the impact of different programming techniques on the stability of feature dependency code in evolving SPLs. This paper presents a first exploratory analysis on the use of programming techniques to implement and evolve feature dependencies. Our analysis was developed in the context of three evolving SPL systems, which are made up of 210 feature dependencies. Our initial findings reveal that two particular types of feature dependency implementation using different programming techniques play a role in the SPL stability.

On the criteria for prioritizing code anomalies to identify architectural problems

Architectural problems constantly affect evolving software projects. When not properly addressed, those problems can hinder the longevity of a software system. Some studies revealed that a wide range of architectural problems are reflected in source code through code anomalies. However, a software project often contains thousands of code anomalies and many of them have no relation to architectural problems. As a consequence, developers struggle to effectively determine which (groups of) anomalies are architecturally relevant. This work proposes criteria for prioritizing groups of code anomalies as indicators of architectural problems in evolving systems.

JSAN: A Framework to Implement Normative Agents

Norms have become a promising mechanism to ensure that open multi-agent systems (MASs) produce a desirable social outcome. MASs can be defined as societies in which autonomous agents work to achieve both societal and individual goals. Norms regulate the behavior of agents by defining permissions, obligations and prohibitions, as well as encouraging and discouraging the fulfillment of norms through rewards and punishments mechanisms. Once the priority of software agent is the satisfaction of its own desires and goals, each agent must evaluate the effects associated to the fulfillment or violation of one or more norms before choosing which one should be complied. This paper introduces a framework for normative MASs simulation that provides mechanisms for understanding the impact of norms on an agent and the society to which an agent belongs.

Architecture-sensitive heuristics for prioritizing critical code anomalies

The progressive insertion of code anomalies in evolving software systems might lead to architecture degradation symptoms. Code anomalies are particularly harmful when they contribute to the architecture degradation. Although several approaches have been proposed aiming to detect anomalies in the source code, most of them fail to assist developers when prioritizing code anomalies critical to the architectural design. Blueprints of the architecture design are artifacts often available in industry software projects. However, such blueprints are rarely explored to support the prioritization of code anomalies in terms of their architecture relevance. This paper proposes and evaluates 2 sets of blueprint-based heuristics for supporting the prioritization of critical code anomalies. The prioritization is based on their potential impact on revealing architectural drift problems. The heuristics allow developers prioritizing critical code anomalies by exploiting architectural information provided in the blueprint. The contributions of this paper include: (i) a set of architecture sensitive heuristics to support developers when prioritizing critical code anomalies; (ii) an evaluation of the proposed heuristics in terms of their prioritization accuracy in 3 systems; and (iii) an empirical analysis on how the blueprints’ information might enhance the prioritization of critical code anomalies, as opposed to existing heuristics strictly based on source code analysis.

Exploring Blueprints on the Prioritization of Architecturally Relevant Code Anomalies -- A Controlled Experiment

The progressive insertion of code anomalies in evolving programs may lead to architecture degradation symptoms. Several approaches have been proposed aiming to detect code anomalies in the source code, such as God Class and Shotgun Surgery. However, most of them fail to assist developers on prioritizing code anomalies harmful to the software architecture. These approaches often rely on source code analysis and do not provide developers with useful information to help the prioritization of those anomalies that impact on the architectural design. In this context, this paper presents a controlled experiment aiming at investigating how developers, when supported by architecture blueprints, are able to prioritize different types of code anomalies in terms of their architectural relevance. Our contributions include: (i) quantitative indicators on how the use of blueprints may improve process of prioritizing code anomalies, (ii) a discussion of how blueprints may help on the prioritization processes, (iii) an analysis of whether and to what extent the use of blueprints impacts on the time for revealing architecturally relevant code anomalies, and (iv) a discussion on the main characteristics of false positives and false negatives observed by the actual developers.

The Development of Normative Autonomous Agents: An Approach

Open multi-agent systems (MASs) act as societies in which autonomous and heterogeneous agents can work towards similar or different goals. In order to cope with the heterogeneity, autonomy and diversity of interests among the different agents in the society, open MASs establish a set of behavioral norms that is used as a mechanism to ensure a state of cooperation among agents. Such norms regulate the behavior of the agents by defining obligations, permissions and prohibitions. Fulfillment of a norm may be encouraged through a reward while violation of a norm may be discouraged through punishment. Although norms are promising mechanisms to regulate an agents behavior, we should note that each agent is an autonomous entity that is free to fulfill or violate each associated norm. Thus, agents can use different strategies when deciding to achieve their goals including whether to comply with their associated norms. Agents might choose to achieve their goals while ignoring their norms, thus overlooking the rewards or punishments they may receive. In contrast agents may choose to comply with all the norms although some of their goals may not be achieved. In this context, this paper proposes a framework for simulation of normative agents providing a basis for understanding the impacts of norms on agents.

On the impact of obliviousness and quantification on model composition effort

Researchers and practitioners advocate that design properties, such as obliviousness and quantification, can improve the modularity of software systems, thereby reducing the effort of composing design models. However, there is no empirical knowledge about how these design properties impact model composition effort. This paper, therefore, performs an empirical study to understand this impact. The main contributions are: (i) quantitative indicators to evaluate to what extent such design properties impact model composition effort; (ii) an objective evaluation of the impact of such modularity properties in 26 versions of two software projects by using statistical tests; and (iii) lessons learned on whether (and how) modularity anomalies related to misuse of quantification and obliviousness in the input models can significantly increase model composition effort.