Experimenting the Influence of Numerical Thresholds on Model-based Detection and Refactoring of Performance Antipatterns

Performance antipatterns are well-known bad design practices that lead to software products suffering from poor performance. A number of performance antipatterns has been defined and classified and refactoring actions have also been suggested to remove them. In the last few years, we have dedicated some effort to the detection and refactoring of performance antipatterns in software models.A specific characteristic of performance antipatterns is that they contain numerical parameters that may represent thresholds referring to either performance indices (e.g., a device utilization) or design features (e.g., number of interface operations of a software component). In this paper, we analyze the influence of such thresholds on the capability of detecting and refactoring performance antipatterns. In particular, (i) we analyze how a set of detected antipatterns may change while varying the threshold values and (ii) we discuss the influence of thresholds on the complexity of refactoring actions. With the help of a leading example, we quantify the influence using precision and recall metrics

applying design patterns to remove software performance antipatterns a preliminary approach

Abstract: Patterns and antipatterns represent powerful instruments in the hands of software designers, for improving the quality of software systems. A large variety of design patterns arose since decades, as well as several performance antipatterns have been defined. In this paper we propose a preliminary approach for antipattern-based refactoring of software systems, driven by design patterns application. The approach is focused on refactoring software artifacts (i.e., models, code) by applying design patterns, with the aim of removing possible performance antipatterns occurring on such artifacts. Based on our approach, design patterns are ranked in order to drive the refactoring choice. We also provide an illustrative example as a preliminary validation of our approach, showing how the ranking method works over three design patterns for removing the Empty Semi-Trucks performance antipattern, and we finally identify future research directions of our work

Envisioning Model-Based Performance Engineering Frameworks.

Abstract Our daily activities depend on complex software systems that must guarantee certain performance. Several approaches have been devised in the last decade to validate software systems against performance requirements. However, software designers still encounter problems in the interpretation of performance analysis results (e.g., mean values, probability distribution functions) and in the definition of design alternatives (e.g., to split a software component in two and redeploy one of them) aimed at fulfilling performance requirements. This paper describes a general model-based performance engineering framework to support designers in dealing with such problems aimed at enhancing the system. The framework relies on a formalization of the knowledge needed in order to characterize performance flaws and provide alternative system design. Such knowledge can be instantiated based on the techniques devised for interpreting performance analysis results and providing feedback to designers. Three techniques are considered in this paper for instantiating the framework and the main challenges to face during such process are pointed out and discussed

Deep Learning Structural and Historical Features for Anti-Patterns Detection

Les systèmes logiciels sont devenus une des composantes principales de tous les secteurs d’activité. Dans la course au rendement économique, les développeurs sont susceptibles d’implémenter des solutions non optimales aux problèmes qui leur sont posés. On nomme ainsi anti-patrons ou “design smells” ces mauvais choix de conception introduits par manque de temps et–ou d’expérience. Si ces derniers n’ont pas forcément d’impact à l’exécution, de nombreuses études ont mis en lumière leur influence négative sur la maintenabilité des systèmes. De nombreuses approches de détection automatique des anti-patrons ont été proposées. Pour la plupart, ces approches reposent sur l’analyse statique du code, mais il a été montré que les anti-pattrons sont aussi détectables par une analyse des données historiques des systèmes. Cependant, aucune d’entre elles ne semble clairement se distinguer des autres, et chaque approche identifie des ensembles d’occurrences différents, en particulier quand celles-ci reposent sur des sources d’information complémentaires (i.e., structurelles vs. historiques). Plusieurs approches basées sur l’apprentissage automatique ont tenté d’adresser ce problème. Toutefois, ces approches semblent faire face à des limitations qui leur sont intrinsèques. D’une part, inférer des caractéristiques de haut niveau sur les systèmes à partir de données brutes nécessite des modèles d’une grande complexité. D’autre part, l’entrainement de tels modèles requière un nombre conséquent d’exemples d’apprentissage, qui sont fastidieux à produire et existent en nombre très limité. Ce travail tire profit des méthodes d’apprentissage automatique pour répondre aux limitations évoquées précédemment. Dans un premier temps, nous proposons une méthode ensembliste permettant d’agréger plusieurs outils de détection. Nous montrons qu’une telle méthode atteint des performances nettement supérieures à celles des outils ainsi agrégés et permet de générer des instances d’apprentissage pour des modèles plus complexes à partir d’un nombre raisonnable d’exemples. Ensuite, nous proposons un modèle d’apprentissage profond pour la détection des anti-patrons. Ce modèle est basé sur l’analyse de l’évolution des métriques logicielles. Plus précisément, nous calculons les valeurs de certaines métriques pour chaque révision du système étudié, et, entrainons un réseau de neurones convolutif à y détecter les anti-patrons à partir de ces données. Nous montrons qu’en s’appuyant ainsi sur les aspects structurels et historiques des systèmes, notre modèle surpasse les approches existantes. Nos approches ont été expérimentées dans le cadre de la détection de deux anti-patrons populaires : God Class et Feature Envy, et leurs performances comparées avec celles de l’état de l’art.----------ABSTRACT: Software systems are constantly modified, whether to be adapted or to be fixed. Due to the exigence of economic performances, these modifications are sometimes performed in a hurry and developers often implement sub optimal solutions that decrease the quality of the code. In this context, the term “anti-pattern” have been introduced to represent such “bad” solutions to recurring design problems. A variety of approaches have been proposed to identify the occurrences of anti-patterns in source code. Most of them rely on structural aspects of software systems but some alternative solutions exist. It has been shown that anti-patterns are also detectable through an analysis of historical information, i.e., by analyzing how code components evolve with one another over time. However, none of these approaches can claim high performances for any anti-pattern and for any system. Furthermore different approaches identify different sets of occurrences, especially when based on orthogonal sources of information (structural vs. historical). Several machine-learning based approaches have been proposed to address this issue. However these approaches failed to surpass conventional detection techniques. On the one hand, learning high level features from raw data requires complex models such as deep neuralnetworks. On the other hand, training such complex models requires substantial amounts of manually-produced training data, which is hardly available and time consuming to produce for anti-patterns. In this work, we address these issues by taking advantage of machine-learning techniques. First we propose a machine-learning based ensemble method to efficiently aggregate various anti-patterns detection tools. We show that (1) such approach clearly enhances the performances of the so aggregated tools and; (2) our method produces reliable training instances for more complex anti-pattern detection models from a reasonable number of training examples. Second we propose a deep-learning based approach to detect anti-patterns by analyzing how source code metrics evolve over time. To do so, we retrieve code metrics values for each revision of the system under investigation by mining its version control system. This information is then provided as input to a convolutional neural network to perform final prediction. The results of our experiments indicate that our model significantly outperforms existing approaches. We experiment our approaches for the detection of two widely known anti-patterns: God Class and Feature Envy and compare their performances with those of state-of-the-art

Understanding the Impact of Poor Coding Practices on the Quality of Deep Learning Systems

RÉSUMÉ:Les applications basées sur l’apprentissage profond, en anglais Deep Learning (DL), sont de plus en plus utilisées pour résoudre diverses tâches de notre quotidien grâce aux recentes prouesses des modèles d’apprentissage profond qui surpassent déjà les compétences humaines dans un large éventail de tâches, de la classification des images à la reconnaissance de la parole et au traitement du langage naturel. Ces progrès tendent à élargir l’application de l’apprentissage profond dans des domaines aussi critiques en termes de sécurité comme les voitures autonomes et la santé. Les spécialistes de l’apprentissage profond partagent les mêmes préoccupations que les ingénieurs logiciels d’ autres domaines en ce qui concerne l’efficacité, la complexité et la maintenabilité des systèmes logiciels. En revanche, le processus de développement continu des systèmes d’apprentissage profond, caractérisé par un rythme rapide et une complexité accrue, pourrait conduire à de mauvais choix de conception par le développeur.---------- ABSTRACT: Deep Learning (DL) based applications are increasingly being used in our society to solve a variety of tasks, thanks to the recent progress of deep learning models, which are now outperforming humans on a wide range of tasks, from image classification to speech recognition and natural language processing. This progress is being made towards the widespread application of DL in safety-critical applications such as autonomous cars and healthcare. Deep learning practitioners share similar concerns as software engineers in other domains with regards to efficiency, complexity, and maintainability. On the other hand, the continuous development of deep learning systems which takes place at a rapid pace as well as their increasing complexity could lead to bad design choices on the part of the developers. Furthermore, due to the prevalent use of similar frameworks and repeated coding of similar tasks, deep learning developers, therefore, tend to use copy-paste practice, creating clones in deep learning cod

Empirical evaluation of an architectural technical debt index in the context of the Apache and ONAP ecosystems

Background. Architectural Technical Debt (ATD) in a software-intensive system denotes architectural design choices which, while being suitable or even optimal when adopted, lower the maintainability and evolvability of the system in the long term, hindering future development activities. Despite the growing research interest in ATD, how to gain an informative and encompassing viewpoint of the ATD present in a software-intensive system is still an open problem. Objective. In this study, we evaluate ATDx, a data-driven approach providing an overview of the ATD present in a software-intensive system. The approach, based on the analysis of a software portfolio, calculates severity levels of architectural rule violations via a clustering algorithm, and aggregates results into different ATD dimensions. Method. To evaluate ATDx, we implement an instance of the approach based on SonarQube, and run the analysis on the Apache and ONAP ecosystems. The analysis results are then shared with the portfolio contributors, who are invited to participate in an online survey designed to evaluate the representativeness and actionability of the approach. Results. The survey results confirm the representativeness of the ATDx, in terms of both the ATDx analysis results and the used architectural technical debt dimensions. Results also showed the actionability of the approach, although to a lower extent when compared to the ATDx representativeness, with usage scenarios including refactoring, code review, communication, and ATD evolution analysis. Conclusions. With ATDx, we strive for the establishment of a sound, comprehensive, and intuitive architectural view of the ATD identifiable via source code analysis. The collected results are promising, and display both the representativeness and actionability of the approach. As future work, we plan to consolidate the approach via further empirical experimentation, by considering other development contexts (e.g., proprietary portfolios and other source code analysis tools), and enhancing the ATDx report capabilities