Code smells indicate potential issues in Software design that can impact maintainability, testing and overall quality. Detecting them early is crucial for improving system reliability. While machine learning has been used for code smell detection, most studies focused on Java, with limited research on other languages. In this study, we empirically investigated the effectiveness of both deep learning and heterogeneous ensemble models in detecting multiple Python code smells, including Large Class, Long Method, Long Scope Chaining, Long Parameter List and Long Base Class List. We evaluated three heterogeneous ensemble models: Stacking, Hard Voting and Soft Voting ensembles, alongside three deep learning models: Convolutional Neural Networks, Long Short-Term Memory and Gated Recurrent Units. Each ensemble was built using eight base models, and the Wilcoxon test was used to assess performance differences. Results indicated that Stacking consistently outperformed other models with superior stability and detection performance. Convolutional Neural Networks performed well in some smells but struggled with complex nested structures, where ensemble models offered more stability. Hard and Soft Voting ensembles were competitive but less stable than Stacking. These findings highlight the potential of ensemble and deep learning models in enhancing Python code smell detection.

ABSTRACT Context Automating code smell detection through a software bot offers significant benefits in terms of efficiency, code quality, and developer productivity. However, careful consideration of accuracy, integration, and user acceptance is also required to realize these benefits fully. While many previous studies have proposed deep learning models for this purpose, they often lack in automating their methodologies. Objective In this paper, we propose the design, development, and deployment of SmellyBot, an AI‐powered bot for code smell detection. Method We seamlessly integrated SmellyBot within the GitHub framework to detect four code smells, incorporating automated reporting to enhance code smell detection. Results Our evaluation involved 43 developers to assess user perception and feature recommendations, alongside an analysis of SmellyBot's performance on six real‐world projects to examine its efficiency and effectiveness. Conclusion The results indicate that developers perceive SmellyBot as highly useful and easy to use, and it has demonstrated notable efficiency and effectiveness in detecting code smells.

Botnets can be a major risk to computer networks, as they attack in dangerous and diverse ways. They are becoming increasingly challenging due to the massive amount of network devices and the obfuscation of communication protocols. This paper provides a critical review and analysis of the recent Machine Learning based models for detecting botnet attacks. It explains the used methodologies, datasets, validation methods, and detection metrics. This paper also identifies the current gaps and limitations to provide recommendations for future research directions in this field. This survey can be used as a guide for new researchers to enhance this research area.

Cyberbullying (CB) is a global dilemma that is growing rapidly to affect more individuals including minors. The devastating consequences of CB indicate a pressing necessity to regulate unethical or illegal users' online behaviors. A remarkable number of researchers attempted to harness the potential of machine learning to detect and prevent such harmful behaviors, however, the existing studies targeting Arabic-based content are still emerging. Therefore, this paper provides a comprehensive review of the published empirical studies in CB detection in Arabic-based content with an emphasis on the adapted methodologies, gaps, and challenges. We hope this work would support researchers in the area of CB-detection to foster a safe online environment and protect against any harmful consequences of CB among users.

Code smells are poor design and implementation choices that hinders the overall software quality. Code smells detection using machine learning models has been an active research area to assist software engineers in identifying smelly code. In this paper, we empirically investigate the detection performance of Voting ensemble in detecting class-level and method-level code smells. We built our Voting ensemble in a heterogeneous manner using five different base models: Decision Trees, Logistic Regression, Support Vector Machines, Multi-Layer Perceptron, and Stochastic Gradient Descent models. Predictions output were aggregated using the Soft voting to form the final ensemble prediction output. Voting ensemble detection performance was evaluated against each base model and within the context of five code smells: God Class, Data Class, Long Method, Feature Envy, Long Parameter List, and Switch Statements smells. Statistical pairwise comparison results indicates the superior performance of Voting ensemble in detecting all code smells, while base models had varying detection performance across code smells.

Umple is an open-source software modeling tool and compiler. It incorporates textual language constructs for UML modeling, including associations and state machines. It includes traits, aspects, and mixins for separation of concerns. It supports embedding methods written in many object-oriented languages, enabling it to generate complete multilingual systems. It provides comprehensive analysis of models and generates many kinds of diagrams, some of which can be edited to update the Umple code. Umple runs on the command line, in a web browser or in integrated development environments. It is designed to help developers reduce code volume, while they develop in an agile, model-driven manner. Umple is also targeted at educational users where students are motivated by its ability to generate real systems from their software models.

Huge benefits are gained when Model Driven Engineering are adopted to develop software systems. However, it remains a challenge for software modelers to embrace the MDE approach. In this paper, we present Umple, a framework for Model Driven Development in Object-Oriented Systems that can be used to generate entire software systems (Model Driven Forward Engineering) or to recover the models from existing software systems (Model Driven Reverse Engineering). Umple models are written using a friendly human-readable modeling notation seamlessly integrated with algorithmic code. In other words, we present a model-is-the-code approach, where developers are more likely to maintain and evolve the code as the system matures simply by the fact that both model and code are integrated as aspects of the same system. Finally, we demonstrate how the framework can be used to elaborate on solutions supporting different scenarios such as software modernization and program comprehension.

Developers using model driven development (MDD) to develop systems lack the ability to specify traces that operate at the model level. This results in specification of traces at the generated code level. In this paper, we are proposing trace directives that operate at the model level to specify the tracing of UML attributes and state machines. Trace directives are implemented as part of the Umple textual modeling language, thus these directives can be expressed in a textual form. Trace code will be injected into system source code that corresponds to trace directives specified at the model level.

Abstract: UML modelling tools provide poor support for composite state machine code generation. Generated code is typically complex and large, especially for composite state machines. Existing approaches either do not handle this case at all or handle it by flattening the composite state machine into a simple one with a combinatorial ex-plosion of states, and excessive generated code. This paper presents a new approach that transforms a composite state machine into an equivalent set of simple state machines before code generation. This avoids the combinato-rial explosion and leads to more concise and scalable generated code. We implement our approach in Umple.We report on a case study, comparing our approach to others in terms of code size and scalability. 1

Identifying faulty classes in object-oriented software is one of the important software quality assurance activities. This paper empirically investigates the application of two popular ensemble techniques (bagging and boosting) in identifying faulty classes in object-oriented software, and evaluates the extent to which these ensemble techniques offer an increase in classification accuracy over single classifiers. As base classifiers, we used multilayer perceptron, radial basis function network, Bayesian belief network, nave Bayes, support vector machines, and decision tree. The experiment was based on well-known and respected NASA dataset. The results indicate that bagging and boosting yield improved classification accuracy over most of the investigated single classifiers. In some cases, bagging outperforms boosting, while in some other cases, boosting outperforms bagging. However, in case of support vector machines, neither bagging nor boosting improved its classification accuracy.