Code smells violate best practices in software development that make code difficult to understand and maintain. Code smell detection tools help practitioners detect maintainability issues and enable researchers to conduct repository mining and empirical research involving code smells. Though significant efforts have been made to effectively detect smells in code, majority of the available tools target programming languages such as Java. Despite the most popular language, a code smell detection tool that can identify not only implementation-level code smells but also support detection of smells at the design granularity is lacking. This paper presents DPy, a code smell detection tool for Python. The tool currently supports eight design smells, eleven implementation smells, and various code quality metrics for Python code. Our replication package includes the tool, instructions to use it, all the validation data and scripts [1]

Infrastructure as Code (IaC) automates the creation, configuration, management, and monitoring of computing infrastructure through code. One of the key principles that IaC promises is repeatability and reproducibility. However, certain programming practices in IaC platforms, especially those that allow imperative configuration, such as Ansible, hinder reproducibility in IaC scripts. This study, first, identifies such programming practices that we refer to as reproducibility smells by conducting a comprehensive multi-vocal literature review and propose a first-ever validated catalog of reproducibility smells for IaC scripts. We implement a tool viz. Reduse to identify reproducibility smells in Ansible scripts. Furthermore, we conduct an empirical study to reveal the proliferation of reproducibility smells in open-source projects and explore correlation and fine-grained co-occurrence relationships among them. We observe that broken dependency chain smell occurs the most in approximately $71 \%$ tasks that we analyzed. Our analysis uncovers significant positive correlations between specific reproducibility smells, implying that repositories with one such smell tend to exhibit others. Moreover, the co-occurrence analysis reveals smell pairs that show a high tendency of co-occurrence at the task granularity. With the developed tool Reduse, DevOps engineers can identify and rectify reproducibility issues before becoming part of the production system. Software engineering researchers can use the smells catalog proposed first in this study and can utilize Reduse in empirical studies exploring various facets of reproducibility.

Deep learning (DL) models are being widely deployed in real-world applications, but their usage remains computationally intensive and energy-hungry. While prior work has examined model-level energy usage, the energy footprint of the DL frameworks, such as TensorFlow and PyTorch, used to train and build these models, has not been thoroughly studied. We present Greenlight, a large-scale dataset containing fine-grained energy profiling information of 1284 TensorFlow API calls. We developed a command line tool called CodeGreen to curate such a dataset. CodeGreen is based on our previously proposed framework FECoM, which employs static analysis and code instrumentation to isolate invocations of Tensor-Flow operations and measure their energy consumption precisely. By executing API calls on representative workloads and measuring the consumed energy, we construct detailed energy profiles for the APIS. Several factors, such as input data size and the type of operation, significantly impact energy footprints. Greenlight provides a ground-truth dataset capturing energy consumption along with relevant factors such as input parameter size to take the first step towards optimization of energy-intensive TensorFlow code. The Greenlight dataset opens up new research directions such as predicting API energy consumption, automated optimization, modeling efficiency trade-offs, and empirical studies into energy-aware DL system design.

Code smell detection tools not only help practitioners and researchers detect maintainability issues but also enable repository mining and empirical research involving code smells. However, current tools for detecting code smells exhibit notable shortcomings, such as limited coverage for a diverse kind of smells at varying granularities, lack of maintenance, and inadequate support for large-scale mining studies. To address the limitations, the first major version of DesigniteJava supported code smells detection at architecture, design, and implementation smells along with commonly used code quality metrics. This paper presents DesigniteJava 2.0 that adds testability and test smell detection support. Also, the tool offers new analysis modes, including an optimized multi-commit analysis mode, to support large-scale multi-commit analysis. We show that the optimized multi-commit mode reduces analysis time by up to 46% without compromising the analysis efficacy. The tool is available online. Replication package including all the validation data and scripts can be found online [27]. Demonstration video can be found on YouTube.

Researchers apply machine-learning techniques for code smell detection to counter the subjectivity of many code smells. Such approaches need a large, manually annotated dataset for training and benchmarking. Existing literature offers a few datasets; however, they are small in size and, more importantly, do not focus on the subjective code snippets. In this paper, we present DACOS, a manually annotated dataset containing 10, 267 annotations for 5, 192 code snippets. The dataset targets three kinds of code smells at different granularity–multifaceted abstraction, complex method, and long parameter list. The dataset is created in two phases. The first phase helps us identify the code snippets that are potentially subjective by determining the thresholds of metrics used to detect a smell. The second phase collects annotations for potentially subjective snippets. We also offer an extended dataset DACOSX that includes definitely benign and definitely smelly snippets by using the thresholds identified in the first phase. We have developed TAGMAN, a web application to help annotators view and mark the snippets one-by-one and record the provided annotations. We make the datasets and the web application accessible publicly. This dataset will help researchers working on smell detection techniques to build relevant and context-aware machine-learning models.

The purpose of scholarly peer review is to evaluate the quality of scientific manuscripts. However, study after study demonstrates that peer review neither effectively nor reliably assesses research quality. Empirical standards attempt to address this problem by modelling a scientific community's expectations for each kind of empirical study conducted in that community. This should enhance not only the quality of research but also the reliability and predictability of peer review, as scientists adopt the standards in both their researcher and reviewer roles. However, these improvements depend on the quality and adoption of the standards. This tutorial will therefore present the empirical standard for mining software repositories, both to communicate its contents and to get feedback from the attendees. The tutorial will be organized into three parts: (1) brief overview of the empirical standards project; (2) detailed presentation of the repository mining standard; (3) discussion and suggestions for improvement.

Architecture smells represent violations of best practices recommended for software architecture that adversely impact various quality attributes of a software system. Though architecture quality is considered very important by the software engineering community, architecture refactoring, given involved high risk and effort, is often avoided by software development teams. In this paper, we empirically explore the properties of architecture smells in the context of the Pareto principle. We investigate the degree of adherence of architecture smell occurrences to the Pareto principle and explore the influence of other related factors i.e., programming language and size of the repositories. To this end, we analyzed 750 Java and 361 C# repositories containing more than 50 million lines of code to detect seven kinds of architecture smells. We found that approximately 45% of the Java repositories follow the Pareto principle. Moreover, C# repositories show significantly higher adherence (66%) to the principle than the repositories written in Java. Our results indicate that the size of the repositories shows a low negative correlation with the Pareto categories. The results imply that software development teams can figure out a few vital components suffering from architecture smells by carrying out the Pareto analysis. It will allow them to optimize their efforts towards making their software architecture quality better.

Code quality aspects such as code smells and code quality metrics are widely used in exploratory and empirical software engineering research. In such studies, researchers spend a substantial amount of time and effort to not only select the appropriate subject systems but also to analyze them to collect the required code quality information. In this paper, we present QScored dataset; the dataset contains code quality information of more than 86 thousand C# and Java GitHub repositories containing more than 1.1 billion lines of code. The code quality information contains seven kinds of detected architecture smells, 20 kinds of design smells, eleven kinds of implementation smells, and 27 commonly used code quality metrics computed at project, package, class, and method levels. Availability of the dataset will facilitate empirical studies involving code quality aspects by making the information readily available for a large number of active GitHub repositories.

Infrastructure as Code (IaC) is the practice of specifying computing system configurations through code, and managing them through traditional software engineering methods. The wide adoption of configuration management and increasing size and complexity of the associated code, prompt for assessing, maintaining, and improving the configuration code's quality. In this context, traditional software engineering knowledge and best practices associated with code quality management can be leveraged to assess and manage configuration code quality. We propose a catalog of 13 implementation and 11 design configuration smells, where each smell violates recommended best practices for configuration code. We analyzed 4,621 Puppet repositories containing 8.9 million lines of code and detected the cataloged implementation and design configuration smells. Our analysis reveals that the design configuration smells show 9% higher average co-occurrence among themselves than the implementation configuration smells. We also observed that configuration smells belonging to a smell category tend to co-occur with configuration smells belonging to another smell category when correlation is computed by volume of identified smells. Finally, design configuration smell density shows negative correlation whereas implementation configuration smell density exhibits no correlation with the size of a configuration management system.