Despite numerous approaches for code smell detection, the current cutting-edge techniques, such as transfer learning (TL), have not been thoroughly investigated in the domain of code smell detection. This study aims to explore the viability of TL for identifying code smells on homogeneous data by leveraging prior knowledge of previously detected code smells. To achieve this objective, the study has defined the problem of identifying code smells on homogeneous data using TL. The experiment utilized publicly accessible homogeneous datasets that include four types of code smells-long method (LM), data class (DC), god class (GC), and feature envy (FE) to assess the effectiveness of a TL technique called domain invariant transfer kernel learning (DITKL). The evaluation of DITKL's performance has been examined using four performance metrics: precision, recall, accuracy, and the area under the receiver operating characteristic curve. The findings indicated an absence of co-occurrence between GC and DC because of inadequate code smell detection from GC to DC and vice versa. Additionally, the findings indicated the viability of identifying code smells such as LM and FE and revealed a significant correlation between the two. This study suggests the effectiveness of using DITKL to identify instances of code smells and their co-occurrences in experimental datasets when two code smells are related. Therefore, the utilization of TL has the potential to aid in the detection of code smells on homogeneous data in situations where a code smell detection tool or expert knowledge is not accessible.
Software fault prediction (SFP) models are often trained on severely imbalanced data. Prior work also warns that low events‑per‑variable (EPV) ratios can yield unstable and biased estimates. To quantify the separate and joint impact of (i) class‑balancing techniques and (ii) EPV ratios on the accuracy and stability of SFP models trained on five real‑world, open‑source GitHub projects. We also examine whether classifier choice outweighs either factor. We extracted five projects from GitHub and built class‑level datasets. After feature selection (genetic algorithm), we evaluated five estimation techniques (PLS, CART, NB, RF, SVM) under a factorial design crossing EPV ∈ (1) with balancing ∈ (None, Up, Down, SMOTE, ROSE) [1]. AUC is used to measure performance. We report effect sizes and stability (across repeated runs) and profile computational cost. Baselines include (a) no balancing at each EPV level and (b) an additional “raw” baseline without EPV adjustment for the only dataset with non‑zero defects (Ceylon). (i) Balancing improves AUC in a minority of settings; SMOTE is the most reliable of the balancing methods, whereas ROSE is the least effective. (ii) EPV = 20 consistently yields higher accuracy and stability than EPV = 3 or 10. (iii) Classifier choice matters most: strong estimation models (RF/SVM) at low EPV often outperform weak estimation techniques (PLS/CART) at high EPV. For modern GitHub‑based SFP, increasing EPV and choosing an appropriate classifier have a greater impact than applying generic class‑balancing. We provide a reproducible protocol (data processing pipeline, seeds, and scripts) and outline an external validation plan on NASA, PROMISE, and Relink.
The development of autonomous vehicles (AVs) increasingly relies on reinforcement learning (RL) within simulated environments. However, many existing frameworks report only end-of-training metrics, providing limited insight into how design choices influence learning outcomes. In this work, we introduce a unified simulation-based RL framework designed for both parking and driving tasks using the Unity engine. Our main contribution is a custom-built Adaptive Dual-Task Curriculum Scheduler (ADCS), which dynamically adjusts task difficulty to accelerate learning. We also develop a diagnostic logging pipeline that records per-step reward, loss, and entropy metrics, enabling fine-grained performance analysis. By integrating both PPO and DQN agents into this framework, we conduct systematic comparisons against multiple baselines and ablated variants. Our results demonstrate that ADCS, in combination with structured reward shaping, reduces training time by over 50
We present a novel energy-efficient scheme for the wireless transmission of streaming video data from Internet of Video Things (IoVT) visual sensors to the backhaul network. Our solution employs a dynamic reference frame selection mechanism powered by a Long Short-Term Memory (LSTM) deep learning model to implement a low-complexity, lossless video data encoding scheme. By exploiting temporal correlations in video frames of the JPEG and JPEG 2000 standards, our dynamic reference frame selection mechanism creates a lossless encoding of the video data by eliminating redundant information. The encoded data is further compressed using the Redundant Binary Number System (RBNS), resulting in a non-uniform distribution of symbols, with 0’s being the most frequent occurring symbol. A silent-symbol transmission strategy is employed to transmit the resulting RBNS-encoded data, transmitting only the non-zero RBNS symbols (1 and 1̅ ), resulting in significant energy savings. Simulation results on real-world traffic surveillance datasets demonstrate transmitter-side energy savings of over 84% (for outdoor scenarios) and 86% (for indoor scenarios) compared to transmitting raw video files. The proposed method ensures lossless data communication with zero Mean Squared Error (MSE). It outperforms the popular encoding techniques based on neighborhood correlation sequence (NCS) method, discrete wavelet transform (DWT), Haar discrete wavelet transform, high efficiency video coding (HEVC) and AV1 in terms of overall energy efficiency, making it highly suitable for energy-constrained IoVT applications.
A key objective of 6G networks is to bridge the digital divide between rural and urban areas by providing ubiquitous Internet connectivity to underserved rural populations. To achieve this, we propose a hybrid network architecture integrating optical fiber cables (OFC), wireless networks (WN), and free-space optics (FSO), which are cost-effective and easily deployable in rural regions. Our solution addresses critical challenges in rural connectivity, offering a scalable and intelligent framework for future 6G networks. An intelligent multi-access routing algorithm is introduced to dynamically route messages through the most appropriate channel of either OFC or WN or FSO, based on real-time conditions. This approach aims to optimize bandwidth utilization, reduce communication latency, minimize jitter, and reduce packet loss rate. A multi-objective optimization problem is formulated to balance these performance metrics, and its solution is implemented as a channel selection algorithm. The proposed algorithm adopts flow-based routing, where each flow represents a session of multiple packets exchanged between users with specific service requirements. User needs are categorized into five primary service classes, each defined by Quality of Service (QoS) parameters, including bandwidth, latency, jitter, and packet loss rate. A Gated Recurrent Unit (GRU) learning model predicts channel characteristics using historical data, enabling optimal channel assignment to each flow, based on real-time conditions and user QoS requirements. The proposed multi-access hybrid routing scheme ensures efficient allocation of network resources while meeting QoS demands, thereby enhancing user satisfaction.
In today’s fast-paced software development environment, organizational survival depends not only on rapid delivery but also on the ability to adapt quickly to evolving requirements. Modern methodologies such as rolling wave planning, evolutionary development, and continuous improvement emphasize early delivery and flexible responses to change. This dynamic nature necessitates effective evaluation of requirement change (RC) requests. However, the absence of a detailed change impact analysis often leads to suboptimal decisions, raising concerns about project success in terms of cost, time, and quality.RC requests can influence various dimensions, including functional requirements (FUR), non-functional requirements (NFR), and project constraints (PRC) (Abran A, Castelo D, Mitwasi GM, Vogelezang F, Aguiar M, Fagg P, Soneira P, Woodward C, Ben-Cnaan P, Lesterhuis A, and Symons C (2015) Glossary of terms for non-functional requirements and project requirements used in software project performance measurement, benchmarking and estimating). As the software project progresses, functional requirements evolve and become increasingly detailed, resulting in varying levels of granularity across the development lifecycle. Early-phase requirements tend to be vague or incomplete, while later stages bring greater clarity. This evolving nature frequently leads to “scope creep,” contributing to delays, cost overruns, and reduced software quality.To address this, we propose a multi-level measures-driven change impact analysis approach for prioritizing RC requests. This approach relies on quantitative assessments conducted at different levels of granularity—namely, the functional level, control structure level, and process level—to guide informed and accurate decision-making. In particular, we leverage COSMIC functional size measurement (The COSMIC Functional Size Measurement Method COSMIC (2020). The Version 5.0, Announcement of Version5.0 of the COSMIC Measurement Manual—March31, 2020) alongside structural size measurement methods (Sellami et al. in Inf Softw Technol 59:222–232, 2015) to evaluate the impact of RC requests on development progress.Our methodology enables both macro-level (functional) and micro-level (structural) impact assessments, helping decision-makers—project managers, analysts, and developers—take appropriate actions. While strategic decisions are supported by process-level metrics, operational decisions benefit from detailed functional and structural measurements. This framework provides a structured, data-driven foundation for managing change across the software lifecycle.
Traditional supervised learning approaches require large, labeled datasets, which can be expensive and time-consuming to obtain. Semi-supervised learning (SSL) approaches, such as soft labelling and pseudo-labelling, have drawn a lot of interest to overcome this difficulty. This study investigates how to combine these methods to improve leaf disease prediction models’ accuracy while reducing their dependency on labelled data. While pseudo-labelling iteratively generates labels for unlabelled samples using reliable model predictions, soft labelling employs uncertainty information to apply probabilistic labels to unlabelled data. Combining these techniques in a semi-supervised framework enhances the model’s robustness and generalization in practical situations. Our approach’s promise for real-world agricultural applications is demonstrated by experimental results that indicate it performs better than fully supervised techniques with limited labelled data. This proposal helps to dispense confidence to the unlabeled data using class probabilities and high confidence predictions are used to redevelop the model gradually. Experimental results demonstrate that the proposed model achieves superior performance compared to fully supervised methods, achieving an accuracy of 96.4
Solidity is a dominant programming language for developing smart contracts on the Ethereum blockchain, playing a crucial role in today’s decentralized applications. Given the rising frequency of security breaches, the verification of Solidity contracts is becoming increasingly essential. Traditionally, vulnerability assessment and formal methods mostly leverage off-the-shelf tools designed for languages other than Solidity by transcompiling the Solidity code into compatible languages. However, Java, known for its comprehensive suite of verification and analysis tools, has seen limited exploration in the context of Solidity. In this paper, we present a semantics-preserving transcompilation of the Solidity language into an equivalent Java counterpart, capturing behavioral aspects of both common and unique Solidity features. We validate the effectiveness of our approach using a set of real Solidity contracts, sourced from OpenZeppelin and Google BigQuery. Further, we showcase the practical benefits of this transcompilation by employing renowned Java testing and analysis tools on the transcompiled code, confirming the potential of integrating Solidity with Java’s robust verification ecosystem.
Software has become an integral part of modern life, serving various purposes in personal, professional, and recreational domains. This research addresses the growing need for software systems that are not only functional but also emotionally resonant with users. While traditional software development focuses on functional and non-functional requirements, the emotional impact of systems on users, referred to as emotional requirements (ERs), remains underexplored. Existing research on ERs has limitations, focusing primarily on specific domains like healthcare or gaming and employing manual, data-dependent elicitation methods. This work proposes a novel and semi-automated approach to derive ERs from system requirements. The proposed methodology addresses three main concerns: (1) identifying requirements with potential emotional triggers, (2) defining a software-specific taxonomy of ERs, and (3) proposing appropriate artifacts and methodology for ER elicitation. A two-way approach is proposed for ER elicitation using formal goal modeling and generative AI. The framework leverages insights from emotional knowledge bases, user behavior patterns, and contextual analysis to systematically derive ERs from requirements. The proposed methodology is experimentally evaluated using case studies of software of different domains.
In today's digital world, organizations connect devices to the Internet for a sustainable and convenient experience. However, this exposes systems to severe cyber-attacks, creating an urgent need for security devices. Due to new technology, the growing complexity of networks necessitates a strong Intrusion Detection System (IDS) to monitor traffic and detect malicious activities. This paper proposes a novel framework that uses deep learning techniques to transform tabular data into image data for known cyber-attack detection. The model includes dimensionality reduction techniques, such as PCA and UMAP, employed sequentially, along with an autoencoder for data transformation. Three different deep learning-based models are used to identify different attacks: a modified Convolutional Neural Network (CNN) enhanced with an attention mechanism, a discriminator neural network from a Wasserstein Conditional Generative Adversarial Network with Gradient Penalty (WCGAN-GP), and a voting classifier that aggregates predictions from the modified CNN and the trained discriminator of WCGAN-GP to improve detection accuracy. Experiments are conducted on the NSL-KDD dataset to showcase enhanced accuracy, precision, recall, and f1-score performance. The proposed model achieves an accuracy of 93
Assigning the most suitable developer to newly reported bugs present a significant challenge for triagers in the software bug life cycle. The diversity in bug components, severity, and priority, coupled with limited background knowledge on new bugs, often hinders efficient resolution. Traditional recommender systems and conventional machine-learning models struggle due to insufficient data on bugs and developers, making them inadequate for this task. While multi-armed bandit (MAB) and contextual multi-armed bandit (CMAB) approaches offer potential solutions, their reliance on limited historical data, slow learning, and rich contextual features restricts their effectiveness. This paper explores the impact of optimization methods such as Direct Method (DM), Inverse Propensity Scoring (IPS), Doubly Robust (DR), and Multi-Task Regression (MTR) on enhancing CMAB algorithm performance. Results demonstrate that these optimizers significantly improve average rewards across various CMAB algorithms across different α values. The proposed CMAB Triage model incorporates these optimizers, effectively addressing challenges such as reward bias, diverse contextual information to improve developer assignment, the cold-start problem, and the balance between exploration and exploitation. Evaluation results show that optimized CMAB models significantly enhance both efficiency and accuracy in developer recommendations for bug repositories. By integrating DM and IPS, our model reduces variance, adjusts for off-policy data, and provides robust, reliable recommendations, illustrating that optimization can realize the full potential of CMAB algorithms in bug triage. By demonstrating the robust performance of optimization-based CMAB models, this work highlights the critical role of optimization in realizing the full potential of CMAB algorithms in bug triage applications.
In today’s dynamic and fast-paced software development landscape, the accurate classification of requirements, particularly distinguishing between functional requirements (FR) and non-functional requirements (NFR), remains a significant challenge. Misclassification often leads to architectural mismatches, increased rework, and delays. Existing machine learning (ML)-based methods often overlook contextual elements, like stakeholder knowledge, organizational structures, and environmental limitations, which may result in incorrect classifications that need rework on large-scale projects. To address this, we propose a context-aware approach that incorporates contextual factor mapping into the classification and feature selection process. We test two text vectorization methods, Bag of Words (BoW) and Chi-Squared (CHI2), and three classifiers, Logistic Regression (LR), Multinomial Naïve Bayes (MNB), and Support Vector Machines (SVM), using the PROMISE_exp dataset. BoW + MNB leads with F1 = 0.73 in an 11-class NFR job, earns an F1 score of 0.92 in binary FR/NFR classification, and both SVM-CHI2 and LR-CHI2 produce F1 = 0.77 in the combined 12-class scenario. These findings demonstrate that adding contextual information significantly improves classification accuracy by lowering misclassification rates and offering practical recommendations to cut down on manual labor and rework. Consequently, our study lays a solid basis for further research on context-aware requirements engineering.
Estimating the number of defects in a software project before the testing phase can reduce the enormous amount of development cost and help in allocating testing resources optimally and efficiently. However, estimating the number of defects in each module of a successive version of the software system will be more efficient in minimizing the development cost. The article proposed a method for estimating the number of defects in the successive version of a software system. The Cross Version Defect Count Estimation (CVDCE) technique estimates the number of defects in the next version of a software system. We proposed a new CVDCE model named Software Defect Count Estimator (SDC-Estimator). We utilized Long and Short Term Memory along with Attention layer architecture in our proposed model. We used seven software projects and their existing versions from the PROMISE repository. First, we have created a meta-content dataset from the different versions of the same software and used it for the training of the proposed model. We compared the performance of the SDC-Estimator with fourteen baseline and three state-of-the-art deep learning methods. We found, that in six out of seven and four out of seven projects, MAE is lowermost, and accuracy is higher respectively, whereas, in two out of seven software, MSE is minimum. We also found the mean of performance measures produced by the proposed model across all seven projects is most optimal compared to baseline methods. The proposed model tackles class imbalance and overfitting problems using random oversampling and dropout regularization, respectively, to produce fair and unbiased results. We observed the improvement of the proposed model on benchmark techniques by inspecting 20% of lines of code. In most situations, the improvements are significant, and it has a large effect size across all seven projects.
In this paper, we deal with the software architecture design of real-time control systems. Given the inherent complexity of such systems on the one hand and the pressing demand for high-quality systems in industry on the other, the design phase becomes paramount. One key objective during this phase is to produce a software architecture that describes a possible realization of the application while adhering to both functional and non-functional requirements, particularly those related to timing. Typically, architects rely on their experience to explore different design alternatives, employing a trial-and-error approach to produce an acceptable architecture. In this paper, we propose the use of real-time patterns to help designers define the appropriate architecture with a trial-and-error strategy. The proposed patterns assist designers in setting design choices and evaluating them using schedulability analysis techniques. These patterns encapsulate the knowledge of a real-time expert in scheduling analysis theory. In addition, to accelerate the process and help designers evaluate various design alternatives, we automate the generation of the analysis model. The obtained results show the applicability of the proposed pattern to a real-life case study and their effectiveness in exploring various software designs.
Model-Based Software Engineering (MBSE) is a development approach aiming to build correct-by-construction systems, provided the use of clear, unambiguous and complete models to describe them along the design process. The approach is supported by several engineering tools, such as the TASTE toolset. TASTE is a pragmatic and mature open-source toolset supported by European Space Agency that enables and provides automation for most of the phases of software system development: (i) heterogeneous system design through several modeling and programming languages, (ii) code generation, build and deployment of the binary application(s), and (iii) validation through static analysis and simulation. One topic left open in TASTE is the formal verification of a system design with respect to specified properties. In this paper we address this shortcoming by introducing model-checking in the TASTE environment. Our approach is based on the IF toolset, that provides the needed model-checking capabilities in an intuitive manner for TASTE engineers. This is mainly due to the similarity between the two formalisms—TASTE and IF, and the complete integration of the model-checker in the IDE (while hiding the implementation details). Our contribution enables a model-checking view in TASTE with specification of properties, execution of the IF model-checker given a user-set configuration, and exploration of the results (e.g., diagnosis) directly by engineers. We describe our implementation and the results obtained by applying our tool on a simple running example and an industrial case study.
Considering programs as data enables powerful meta-programming. One example is Lisp’s macro system, which gives rise to powerful transformations of programs and allows easy implementation of domain-specific languages. Formal specifications, however, usually do not rely on such mechanisms and are mostly written by hand in a textual format (or using specialised domain-specific language (DSL) tools). In this paper, we investigate the opportunities that stem from considering specifications as data. For this, we embedded the B specification language in Clojure, a modern Lisp. We use Clojure as a functional meta-programming language and the ProB Java API to capture the semantics of B, i.e., to find solutions for constraints or animate machines. From our experience, it is especially useful for tool development and generation of constraints and machines from external data sources. It can also be used to implement language extensions and to design DSLs.
Code smells have an adverse impact on the quality of source code. Martin Fowler initially identified a set of 22 code smells. Since the term "code smell", there have been multiple attempts to understand them through their detection and to discover relationships between them using correlation and other approaches. The literature demonstrates multiple studies in which code smells have been found to exhibit relationships with other code smells. Nevertheless, the temporary field is one of the 22 code smells that has not been analysed to determine its relationship with other code smells. It is important to consider temporary field, as it has a detrimental impact on the maintainability of the source code. The study has conducted a review of the 7 smell relations identified by Pietrzak and Walter and proposed 3 new smell relations. It has evaluated these smell relations between temporary field and 17 design smells in 10 popular open-source Java applications that are widely cited in the literature and publicly accessible. The study has also done a correlation analysis of temporary field with 17 design smells. All code smells in the study were detected using an open-source tool called "TFfinder". The study reveals 18 significant smell relations between temporary field and design smells. Utilization of smell relations can facilitate an in-depth comprehension of code smells and aid in the prioritization of code smells for refactoring purposes. In addition, it can assist a developer in identifying classes that need more maintenance effort and impact the maintainability of the code.
Integration of Software Product Line (SPL) and Agile Software Development (ASD) results in a new direction called Agile Product Line Engineering (APLE). Even though some studies in the literature have suggested efficient methods for integrating ASD and SPL, they have not yet addressed every facet of APLE’s characteristics, and these methods hardly ever take into account the SPL configuration process or the reuse of software resources when developing new products or expanding existing product lines. Despite extensive research efforts, a unified and holistic APLE methodology that integrates agile concepts across both Application Engineering (AE) and Domain Engineering (DE) phases remains elusive. Given this, we suggest a new APLE methodology to integrate ASD and SPL more effectively. The suggested approach iteratively builds the product line, and the system architecture grows over time. We have outlined a new variability mechanism called Variability on DemAnd (VODA) to boost the SPL configuration process. We performed the two-phased evaluation. (1) In the first phase, we considered empirical investigation to validate the proposed APLE methodology. We performed a randomized experiment to compare the proposed approach to a traditional system that typically applies agile principles within a proactive SPL but lacks agile-based variability mechanisms, dynamic product line architectures, and robust feedback. (2) In second phase, the proposed algorithm is tested for efficiency, performance, and effectiveness. We conduct the experiments to evaluate the proposed process (VODA) and obtained results are evaluated with Precision, Recall, Accuracy, and F-Measure. The findings indicate that the suggested approach offers benefits such as adaptable demand management, improved software resource reuse, lower configuration costs, and a shorter time to market. The second step (i.e. second phase of evaluation) results confirm the effectiveness of the proposed algorithm. The average precision value is 0.887, the average Recall value is 0.884 and the average F-Measure value is 0.878
Effort estimation is crucial in the early stage of the software development life cycle. Inaccurate estimation often leads to project failures, which is a pervasive issue nowadays for software project managers. For the software’s high performance, well-known estimating methods such as the Constructive Cost Model (COCOMO) need improvement in terms of parameter optimization. The objective of this work is to develop an effective framework that refines the parameters of COCOMO II model aiming to predict and improve estimation accuracy. We proposed an improved parameters tuning method for COCOMO II using a novel metaheuristic adaptive memetic improved anti-predatory nature-inspired algorithm (Ada-MIAPNIA). The algorithm adapts weight modifications through Lévy flight-inspired motions, enhancing global search effectiveness and optimizing the equilibrium between exploratory and exploitative approaches. Furthermore the proposed algorithm is also incorporating elitism, to ensures the retention of the optimal solution throughout each optimization stage. The effectiveness of the Ada-MIAPNIA was rigorously evaluated using 31 benchmark functions, with its performance validated through statistical tests. The experimental findings demonstrate that the proposed Ada-MIAPNIA outperforms other counterpart nature-inspired algorithms (NIAs). The proposed framework’s performance is further solidified through an evaluation using NASA software project datasets, which reinforces the algorithm’s efficacy. The results were validated using evaluation criteria such as Mean Magnitude of Relative Error (MMRE) and prediction (0.25). Ada-MIAPNIA outperforms the existing COCOMO II model and other nature-inspired algorithms (NIAs) by substantial margins, ranging from 2.02 to 31.94
For the consolidated management and supervising of massive networks, software-defined networking (SDN) is seen to be the best option. Nonetheless, it should be highlighted that SDN design experiences the same security problems as conventional networks. To bridge this gap, an efficient model for anomaly detection (AD) in SDN named Multi-verse Deer Hunting Optimization (MVDHO) is introduced. Firstly, SDN nodes are simulated. After that, SDN switches are controlled by the control plane to identify the condition of switches like ON, IDLE, or OFF conditions based on the detection plane. Secondly, the detection plane module consists of two modules, such traffic flow detection and AD. In the detection plane, the SDN switch flow rate is recorded in the form of time-series data and the condition of the switch is predicted based on time-series data using Deep Long short-term memory (LSTM). Similarly, in AD, the behaviour of the communication is recorded as a log file by extracting the significant features. Moreover, appropriate features are selected by mutual information. Finally, the detection of anomaly is performed employing Deep Q-Network, which is trained using MVDHO. Here, MVDHO is obtained by the combination of a Multi-verse Optimizer (MVO) and Deer Hunting Optimization Algorithm (DHOA). The detected anomalies are Denial of Service (DoS), Buffer_overflow, Guess_password, SQL attack and Named attack. The metrics utilized in this research namely, Traffic flow detection accuracy (TFDA), accuracy, true positive rate (TPR), and true negative rate (TNR) attained maximum values with 91.6
