Search

Educational CubeSats still remain valuable hands-on practice activity in an academic environment and provide effective and innovative solutions from technical and management points of view. Fast delivery and low cost is the paradigm driving such projects. Contemporary, the simplicity of the solutions has to match with reliability to guarantee the success of the on orbit operations. The present paper shows the entire life cycle of a Sensing Suite System suitable as scientific data collector within a CubeSat, developed in less than four months from the conceptual design to the delivery and reaching the orbit in less than six months. Technical solutions for hardware and software development and test and management good practices are provided. Circuits details to withstand and/or tolerate the space environment and data handling to maximize the number of data and measurements gathered onboard are explained. The use of breadboards and flat-sat arrangements support both the design and verification of the protoflight comprising the schedule and increasing the confidence level on the goodness of the entire solution. The reliability of the design is proven through the entire assembly, integration and verification campaign and validated by the data sent by the satellite during the operative mission. • Fast delivery and low budget educational cubesat payload is presented. • Simple and reliable avionics system for small satellites is provided with details on software and hardware development. • Derails of schedule definition and management with the related lesson learned are shown. [ABSTRACT FROM AUTHOR]

Software reliability growth models (SRGMs) are used to estimate future failure rates and the number of residual defects in software. SRGM helps reliability software engineers make test termination decisions. Although more than 250 traditional SRGMs have been proposed for reliability assessment, research to develop more reliable models is still ongoing. Recently, new methods based on neural networks have been developed to improve the accuracy of software reliability assessment. The article develops a neural network algorithm for assessing software reliability. To do this, factors affecting software reliability and covering its life cycle were assessed. Based on them, sets for training a three-layer neural network were created. [ABSTRACT FROM AUTHOR]

The method of recognizing faults in a software system is acknowledged as software fault prediction. Software faults predicted in prior stages help in the management of resources and time required during software testing and maintenance. The identified software module can be fixed ahead of time, saving time and money near the end of the software development process. Over the years, various supervised machine learning-based techniques for fault prediction have been suggested. These models' accuracy is based on the training datasets. The models are created and trained using a labeled dataset consisting of multiple independent variables like lines of codes, the complexity of the software, the size of the software, etc., and a dependent binary variable, either true or false. But the fault dataset may have some concerns like a class overlapping problem, class imbalance problem, null values, etc. Recent research in software fault prediction focuses on data quality. An imbalanced dataset is one in which one of the class data is present in the majority and another class data is present in the minority. Models built using imbalanced datasets are biased which results in inaccurate predictions. Therefore, balancing the dataset is important. In this paper, the most recent software fault prediction algorithms, which focus on class imbalance issues are discussed. A comparative presentation is presented in this paper, which would benefit the scholar in selecting the best techniques of fault prediction based on different datasets and algorithms. According to the survey, SMOTE is the most commonly used data sampling technique for dealing with data quality issues. [ABSTRACT FROM AUTHOR]

Predicting faults in software aims to detect defects before the testing phase, allowing for better resource allocation and high-quality software development, which is a requisite for any organization. Machine learning techniques aid in the resolution of such issues and a variety of predictive models are being developed to categorize the software into defective modules and the one which is non-defective ones. Though applying these advanced machine learning techniques results in better utilization of time and other resources, there is still poor prediction as reported in many studies. This is because of several challenges that block defective software data, including redundancy, correlation, feature irrelevance, missing samples, and an imbalanced distribution between the faulty and non-faulty classes. Ensemble Machine learning has been adopted by practitioners and researchers globally to deal with such problems, and it is proven to demonstrate some improvement in defect prediction performance. In this review paper, all ensemble-based machine learning techniques developed for software defect prediction from 2018 to 2021 have been critically analyzed. The nucleus of this paper is to get a deep insight into why the various hybrid models still suffer from poor performance on the available datasets. A detailed review with a focus on multiple perspectives viz. faulty and non-defective datasets, performance evaluation criteria, and machine learning techniques have revealed certain gaps that can be addressed by developing more robust hyperparameter optimization algorithms, feature engineering, developing stacking and averaging models. [ABSTRACT FROM AUTHOR]

Software testing plays a critical role in the development and the assurance of the software quality. However, the quality of the code that is responsible for testing may, itself, be affected by poor design choices, known as test smells. In the literature, test smells may be interpreted differently by developers, which in turn can lead to different detection tools and results. In our work, we have selected the mostly commonly used detection tools and have investigated their overall agreement across different projects and different test smells. The found results were evaluated according to the average level of agreement, where we observed a definite disagreement between the tools. To overcome this gap of misinterpretation, we propose in this paper a multi-label classification approach to detect test smells based on a deep representation of the test code. We conducted our experiments using 4 problem-transformation techniques and 4 ensemble techniques. To evaluate our experimental results, we built a benchmark using a tool-based approach for labelling and made it publicly available. Binary Relevance and RAkEL are found to be the best multi-label techniques that achieve high performance results. [ABSTRACT FROM AUTHOR]

Project management has long been a challenge for Information Technology (IT) organizations to learn how to manage projects effectively and efficiently while balancing the iron triangle: cost, time and scope without sacrificing quality. Agile project management (APM) and traditional project management (TPM) are two different approaches related to software development, the core tenet of TPM is that projects are relatively simple, predictable, and linear with well-defined boundaries, whereas APM has emerged as a new methodology for managing high-risk, time-sensitive and scope flexible projects. While it is undeniable that the use of agile project management is increasing, the traditional opposite side continues to exist. The agile approach has an impact on all phases of software development, and they must adapt to this new way of thinking. Software testing is also impacted as a fundamental link in the software development life cycle that ensures quality. Software testing is a vital component of software Quality Assurance (QA) since it serves as the final review of the specification, design, and code. Has software testing evolved along with the evolution of project management? Is there a difference between a traditional and an agile software testing? This paper answers these questions by comparing software testing in the two approaches. [ABSTRACT FROM AUTHOR]

[Display omitted] • Quantum computers' noise and errors are exploitable resulting in security breaches. • Current stability and security approaches can provide a quantum security model. • The static analysis would be essential in ensuring security of quantum software. Quantum computing is no longer a promise of the future but a rapidly evolving reality. Advances in quantum hardware are making it possible to make tangible a computational reality that until now was only theoretical. The proof of this is that development languages and platforms are appearing that bring physical principles closer to developers, making it feasible to begin to propose, in different areas of society, solutions to problems that until now were unsolvable. However, security vulnerabilities are also emerging that could hinder the progress of quantum computing, as well as its transition and development in industry. For this reason, this article proposes a review of some of the first artefacts that are emerging in the field of quantum computing. From this analysis, we begin to identify possible security issues that could become potential vulnerabilities in the quantum software of tomorrow. Likewise, and following the experience in classical software development, the testing technique is analysed as a possible candidate for improving security in quantum software development. Following the principles of Quantum Software Engineering, we are aware of the lack of tools, techniques and knowledge necessary to guarantee the development of quantum software in the immediate future. Therefore, this article aims to offer some first clues on what would be a roadmap to guarantee secure quantum software development. [ABSTRACT FROM AUTHOR]

With the rise of agile development notion, software test automation is widely adopted by software organizations to reduce the testing time and costs during the software development process. However, it is essential to carefully implement the test automation to ensure the project's success. In the literature, several studies have indicated that decision-making is crucial for the adoption of test automation. For deciding about test automation adoption, several factors, including the skill level of testers, test tool, and development process, need to be considered since automated testing performance heavily depends on the mentioned factors and their interactions. Thus, it is of vital importance to ascertain the factors that influence test automation in the context of Agile-based Software Development (ASD). To accomplish this, we perform a systematic literature review and a questionnaire-based survey. In total, 21 factors are identified that significantly impact test automation in the ASD context. Additionally, the identified factors are categorized into five main classes. Following the identified factors' assessment, this work proposes a conceptual model that supports agile practitioners in deciding about the adoption of test automation in the context of ASD. Finally, this work validates the proposed model to assess its practical applicability. The validation of the proposed model is accomplished by using an expert-based validation approach. The attained results show that the proposed model supports agile practitioners in estimating the possibility of success when implementing test automation in the ASD context. [ABSTRACT FROM AUTHOR]

With the growing demand for application software, there is a race among industries to develop software as quickly as possible. However, maintaining pace and ensuring bug-free software has become increasingly challenging in a work-from-home arrangement as software developers are not under constant supervision. It increases the possibility of buggy products, and traditional testing techniques fail to provide optimal performance. We propose an Artificial Intelligence (AI) and blockchain-based novel decentralized software testing system. The proposed system aims to detect and prevent vulnerable code by synergizing deep learning capabilities and smart-contract-powered blockchain. The vulnerability detection is performed automatically without relying on manually written rules. We propose a non-vulnerability score range map to classify the source code. Furthermore, we integrate an InterPlanetary File System (IPFS) to ensure efficient storage over the blockchain. We conduct a testbed-based experiment to demonstrate the effectiveness of AI and blockchain integration for secure code development and testing. [Display omitted] • Software testing is one of the vital phases in the software development life cycle. • AI can automate the code testing process for vulnerability detection. • A blockchain-based system ensures transparency and trust in software development. • Integrating AI and Blockchain can enhance the software testing lifecycle. [ABSTRACT FROM AUTHOR]

Defect prediction is commonly used to reduce the effort from the testing phase of software development. A promising strategy is to use machine learning techniques to predict which software components may be defective. Features are key factors to the prediction's success, and thus extracting significant features can improve the model's accuracy. In particular, code smells are a category of those features that have been shown to improve the prediction performance significantly. However, Design code smells, a state-of-the-art collection of code smells based on the violations of the object-oriented programming principles, have not been studied in the context of defect prediction. In this paper, we study the performance of defect prediction models by training multiple classifiers for 97 real projects. We compare using Design code smells as features and using other Traditional smells from the literature and both. Moreover, we cluster and analyze the models' performance based on the categories of Design code smells. We conclude that the models trained with both the Design code smells and the smells from the literature performed the best, with an improvement of 4.1% for the AUC score, compared to models trained with only Traditional smells. Consequently, Design smells are a good addition to the smells commonly studied in the literature for defect prediction. [ABSTRACT FROM AUTHOR]

• Detecting code changes responsible for performance regression is time-consuming. • Dynamic analysis is a credible source in detection performance regression but expensive. • Detecting performance regression problem formulated as optimization problem. • Detection rules generated by using a multi-objective evolutionary algorithm. In contemporary software development, developers commonly conduct regression testing to ensure that code changes do not affect software quality. Conducting performance regression testing after every code change is known to be expensive which emigres the need to direct the performance regression testing efforts on code changes that are most likely introducing performance regression. In this paper, we exploit code change metrics to identify the group introducing the regression based on a pre-trained detection rule. We present PRICE approach as a new formulation of detecting code changes introducing performance regression as an optimization problem using multi-objective evolutionary algorithms. PRICE evaluated using a set of 8000 commits, extracted from the Git project. Results show the effectiveness of our approach in accurately detecting performance regression introducing code changes. The average regression detection PRICE provides is 77% which is 22% more than the state-of-the-art deterministic approach. This improvement didn't compromise the detection of the contradicted code changes that are not introducing a regression. PRICE provides detection of code changes not introducing a regression averaged 63%, which is also an improvement of 14% than the comparative approach. Using PRICE, we were able to explore new search spaces and provide competing results. [ABSTRACT FROM AUTHOR]

As blockchain technology is gaining popularity in industry and society, solutions for Verification and Validation (V&V) of blockchain-based software applications (BC-Apps) have started gaining equal attention. To ensure that BC-Apps are properly developed before deployment, it is paramount to apply systematic V&V to verify their functional and non-functional requirements. While existing research aims at addressing the challenges of engineering BC-Apps by providing testing techniques and tools, blockchain-based software development is still an emerging research discipline, and therefore, best practices and tools for the V&V of BC-Apps are not yet sufficiently developed. In this paper, we provide a comprehensive survey on V&V solutions for BC-Apps. Specifically, using a layered approach, we synthesize V&V tools and techniques addressing different components at various layers of the BC-App stack, as well as across the whole stack. Next, we provide a discussion on the challenges associated with BC-App V&V, and summarize a set of future research directions based on the challenges and gaps identified in existing research work. Our study aims to highlight the importance of BC-App V&V and pave the way for a disciplined, testable, and verifiable BC development. [ABSTRACT FROM AUTHOR]

DevOps is an emerging paradigm that refer to a collaborative culture of development and operation teams aiming to develop the high quality software product. Software organizations are adopting DevOps culture for software development and easy maintenance instead of using traditional SDLC mechanism. To enter the production stage, in DevOps process, the software product have to pass through quality gates were the software are tested during development phase to meet the established targeted criteria. This indicates that the mechanism of testing in DevOps process is not straightforward, and to establish strong DevOps testing platform there is a need to explore more automated testing practices. Thus, using multivocal literature review approach, we have selected 39 studies and identify the 20 testing capabilities. Finally, the interpretive structure modeling (ISM) and fuzzy technique for order preference by similarity to ideal solution (fuzzy TOPSIS) were applied. The results shows that (C2, CCi=0.808; C6, CCi=0.720; and C3, CCi=0.705) are top ranked testing capabilities. Using analysis results, we develop a holistic structure of testing capabilities to show their inter-relationship with each other and their priorities to select the best testing capabilities for DevOps process. • Identification of DevOps testing capabilities. • Application of ISM approach to analyze the interaction among the testing capabilities. • Determination of relative importance for each identified testing capability. [ABSTRACT FROM AUTHOR]