Continuous Integration Environment Research Articles

Optimizing ambulance nurse performance in southern Tuscany: insights from a Delphi study

This study aims to enhance the performance of ambulance nurses in Southern Tuscany through a Delphi method analysis. Conducted from January to December 2022, the research engaged 16 expert participants from a Tuscan health agency. Data on 89 interventions performed by "India" ambulances, which are nurse-led emergency vehicles, were collected. The Delphi method facilitated structured communication among the experts over three rounds, resulting in consensus on nine key intervention proposals. These proposals span areas including staff training, measurement and data collection methods, technologies and materials, and work environments. Key recommendations include prioritizing high-fidelity simulation training, improving data collection for clinical risk, and standardizing equipment across all emergency units. The study highlights the importance of continuous professional development, technological integration, and supportive work environments to optimize the effectiveness of pre-hospital emergency care. These findings provide a practical roadmap for enhancing the competencies and performance of ambulance nurses, ultimately improving patient outcomes in emergency situations.

Quantum Information Technologies in Cybersecurity: Developing Unbreakable Encryption for Continuous Integration Environments

Quantum Information Technologies in Cybersecurity: Developing Unbreakable Encryption for Continuous Integration Environments

A Roadmap for Using Continuous Integration Environments

Visualizing CI's role in software quality attribute evaluation.

Automated NFR testing in continuous integration environments: a multi-case study of Nordic companies

ContextNon-functional requirements (NFRs) (also referred to as system qualities) are essential for developing high-quality software. Notwithstanding its importance, NFR testing remains challenging, especially in terms of automation. Compared to manual verification, automated testing shows the potential to improve the efficiency and effectiveness of quality assurance, especially in the context of Continuous Integration (CI). However, studies on how companies manage automated NFR testing through CI are limited.ObjectiveThis study examines how automated NFR testing can be enabled and supported using CI environments in software development companies.MethodWe performed a multi-case study at four companies by conducting 22 semi-structured interviews with industrial practitioners.ResultsMaintainability, reliability, performance, security and scalability, were found to be evaluated with automated tests in CI environments. Testing practices, quality metrics, and challenges for measuring NFRs were reported.ConclusionsThis study presents an empirically derived model that shows how data produced by CI environments can be used for evaluation and monitoring of implemented NFR quality. Additionally, the manuscript presents explicit metrics, CI components, tools, and challenges that shall be considered while performing NFR testing in practice.

An Evaluation of Ranking-to-Learn Approaches for Test Case Prioritization in Continuous Integration

Continuous Integration (CI) environments is a practice adopted by most organizations that allows frequent integration of software changes, making software evolution more rapid and cost-effective. Such environments require dynamic Test Case Prioritization (TCP) approaches that adapt better to the test budgets and frequent addition/removal of test cases. In this sense, Ranking-to-Learn approaches have been proposed and are more suitable for CI constraints. By observing past prioritizations and guided by reward functions, they learn the best prioritization for a given commit. In order to contribute for improvements and direct future research, this work evaluates how far the solutions produced by these approaches are from optimal solutions produced by a deterministic approach (ground truth). To this end, we consider two learning-based approaches i) RETECS, which is based on Reinforcement Learning; and ii) COLEMAN, an approach based on Multi-Armed Bandit. The evaluation was conducted with twelve systems, three test budgets, two reward functions, and six measures concerning fault detection effectiveness, early fault detection, test time reduction in the CI cycles, prioritization time, and accuracy. Our findings have some implications for the approaches application and reward function choice. The approaches are applicable in real scenarios and produce solutions very close to the optimal ones, respectively, in 92% and 75% of the cases. Both approaches have some limitations to learn with few historical test data (a small number of CI Cycles) and deal with a large test case set, in which many failures are distributed over many test cases.

Approach to end-to-end testing of the application for managing the configuration of enterprise virtual infrastructure

The article is devoted to end-to-end testing of the application for managing the configuration of enterprise virtual infrastructure. The main idea is to develop a software framework to create and perform end-to-end tests written in Python. The approach involves a comprehensive evaluation of the system from the user interface to the database. The testing process is performed in a continuous integration environment, which enables the team to test the system continually as new code is added. The testing process also includes the use of automated tests written in Python. The automated tests allow for faster and more reliable testing and enable the team to test the system across multiple platforms and configurations. The approach also includes the use of virtual environments to simulate the production environment. This enables the team to identify potential issues that may arise in the production environment and to test the system's performance under various conditions.

Automated Nfr Testing in Continuous Integration Environments: A Multi-Industry Case Study

Automated Nfr Testing in Continuous Integration Environments: A Multi-Industry Case Study

P2ISE: Preserving Project Integrity in CI/CD Based on Secure Elements

During the past decade, software development has evolved from a rigid, linear process to a highly automated and flexible one, thanks to the emergence of continuous integration and delivery environments. Nowadays, more and more development teams rely on such environments to build their complex projects, as the advantages they offer are numerous. On the security side however, most environments seem to focus on the authentication part, neglecting other critical aspects such as the integrity of the source code and the compiled binaries. To ensure the soundness of a software project, its source code must be secured from malicious modifications. Yet, no method can accurately verify that the integrity of the project’s source code has not been breached. This paper presents P2ISE, a novel integrity preserving tool that provides strong security assertions for developers against attackers. At the heart of P2ISE lies the TPM trusted computing technology which is leveraged to ensure integrity preservation. We have implemented the P2ISE and quantitatively assessed its performance and efficiency.

Quantum Information Technologies in Cybersecurity: Developing Unbreakable Encryption for Continuous Integration Environments

Due to the evolving nature of cyber threats, adequate protection of CI environments, a crucial component of the modern DevOps pipeline, remains an essential problem. Quantum cryptography, based on the principles of quantum mechanics, seems to provide a solution to improve the security of data transmissions in these contexts. This paper analyses QKD's suitability for establishing secure communication protocols in CI systems. By illustrating simulation reports and real-life examples, this paper shows how quantum cryptographic approaches can help avoid threats related to traditional encryption algorithms. Leveraging quantum-safe cryptographic solutions to fill the existing security loopholes is a solution to modern cyber threats. However, problems like implementation costs, technological barriers, and performance decline as the number of users increases are other barriers that need to be addressed to see the full potential of quantum cryptography in CI environments. The paper ends with tactical conclusions regarding creating secure CI settings with QE to further examine and implement in cybersecurity.

Enhancing the efficiency of continuous integration environment in DevOps

Faster release of features to the production environment is the need of the hour of every IT organizations. This faster and continuous software delivery is made possible through DevOps. DevOps is a set of practices that bridges the gap between development team and operations team. The different aspects of DevOps came from agile methodology. Continuous integration is the paramount of DevOps life cycle. In a continuous integration development practice, the development code and the applications code are continuously integrated several times a day. Developers follow the practice of committing changes frequently into the version control system such as git. A change in the version control system triggers the continuous integration system such as Jenkins. This exploratory study presents the ways that support the developers during the build break in continuous integration environment and thereby improve the efficiency of continuous integration process. Our findings contribute that the selected list of plugins in the Jenkins support the developers during the build break, thus developers can come up with faster recovery of build failures which in turn increase the efficiency of continuous integration environment.

Know You Neighbor: Fast Static Prediction of Test Flakiness

Context: Flaky tests plague regression testing in Continuous Integration environments by slowing down change releases and wasting testing time and effort. Despite the growing interest in mitigating the burden of test flakiness, how to efficiently and effectively detect flaky tests is still an open problem. Objective: In this study, we present and evaluate FLAST, an approach designed to statically predict test flakiness. FLAST leverages vector-space modeling, similarity search, dimensionality reduction, and k-Nearest Neighbor classification in order to timely and efficiently detect test flakiness. Method: In order to gain insights into the efficiency and effectiveness of FLAST, we conduct an empirical evaluation of the approach by considering 13 real-world projects, for a total of 1,383 flaky and 26,702 non-flaky tests. We carry out a quantitative comparison of FLAST with the state-of-the-art methods to detect test flakiness, by considering a balanced dataset comprising 1,402 real-world flaky and as many non-flaky tests. Results: From the results we observe that the effectiveness of FLAST is comparable with the state-of-the-art, while providing considerable gains in terms of efficiency. In addition, the results demonstrate how by tuning the threshold of the approach FLAST can be made more conservative, so to reduce false positives, at the cost of missing more potentially flaky tests. Conclusion: The collected results demonstrate that FLAST provides a fast, low-cost and reliable approach that can be used to guide test rerunning, or to gate the inclusion of new potentially flaky tests.

Statical and Dynamical Software Analysis

The development of software built with quality has become an important trend and a natural choice in many organisations. Currently, methods of measurement and assessment of software quality, security, trustworthiness cannot guarantee safe and reliable operations of software systems completely and effectively.In this article statistical and dynamical software analysis methods, main concepts and techniques families are overviewed.The article has an overview of why combination of several analysis techniques is necessary for software quality and examples how static and dynamical analysis may be introduced in a modern agile software development life cycle.As a summary of techniques for software analysis, represented on Table 1, due to the computability barrier, no technique can provide fully automatic, robust, and complete analyses. Testing sacrifices robustness. Assisted proving is not automatic (even if it is often partly automated, the main proof arguments generally need to be human provided). Model-checking approaches can achieve robustness and completeness only with respect to finite models, and they generally give up completeness when considering programs (the incompleteness is often introduced in the modeling stage). Static analysis gives up completeness (though it may be designed to be precise for large classes of interested programs). Last, bug finding is neither robust nor complete. Another important dimension is scalability. In practice, all approaches have limitations regarding scalability, although these limitations vary depending on the intended applications (e.g., input programs, target properties, and algorithms used).Already implemented code could be analysed in a continuous integration environment by a tool like SonarQube. Properly configured metrics and quality gates provide fast and detailed feedback on incremental changes starting from development machine till highload enterprise production environments. Software analysis helps to improve quality and development speed in Agile development life cycle with reasonable cost.Manuscript received 16.05.2020

A Multi-Armed Bandit Approach for Test Case Prioritization in Continuous Integration Environments

Continuous Integration (CI) environments have been increasingly adopted in the industry to allow frequent integration of software changes, making software evolution faster and cost-effective. In such environments, Test Case Prioritization (TCP) techniques play an important role to reduce regression testing costs, establishing a test case execution order that usually maximizes early fault detection. Existing works on TCP in CI environments (TCPCI) present some limitations. Few pieces of work consider CI particularities, such as the test case volatility, that is, they do not consider the dynamic environment of the software life-cycle in which new test cases can be added or removed (discontinued), characteristic related to the Exploration versus Exploitation (EvE) dilemma. To solve such a dilemma an approach needs to balance: i) the diversity of test suite; and ii) the quantity of new test cases and test cases that are error-prone or that comprise high fault-detection capabilities. To deal with this, most approaches use, besides the failure-history, other measures that rely on code instrumentation or require additional information, such as testing coverage. However, to maintain the information updated can be difficult and time-consuming, not scalable due to the test budget of CI environments. In this context, and to properly deal with the TCPCI problem, this work presents an approach based on Multi-Armed Bandit (MAB) called <monospace xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">COLEMAN</monospace> ( <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"><b>C</b>ombinatorial V<b>O</b>lati<b>LE</b> <b>M</b>ulti-Armed B<b>AN</b>dit</i> ). The TCPCI problem falls into the category of volatile and combinatorial MAB, because multiple arms (test cases) need to be selected, and they are added or removed over the cycles. We conducted an evaluation considering three time budgets and eleven systems. The results show the applicability of our approach and that <monospace xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">COLEMAN</monospace> outperforms the most similar approach from literature in terms of early fault detection and performance.

Test Case Prioritization in Continuous Integration environments: A systematic mapping study

Abstract Context: Continuous Integration (CI) environments allow frequent integration of software changes, making software evolution more rapid and cost-effective. In such environments, the regression test plays an important role, as well as the use of Test Case Prioritization (TCP) techniques. Such techniques attempt to identify the test case order that maximizes certain goals, such as early fault detection. This research subject has been raising interest because some new challenges are faced in the CI context, as TCP techniques need to consider time constraints of the CI environments. Objective: This work presents the results of a systematic mapping study on Test Case Prioritization in Continuous Integration environments (TCPCI) that reports the main characteristics of TCPCI approaches and their evaluation aspects. Method: The mapping was conducted following a plan that includes the definition of research questions, selection criteria and search string, and the selection of search engines. The search returned 35 primary studies classified based on the goal and kind of used TCP technique, addressed CI particularities and testing problems, and adopted evaluation measures. Results: The results show a growing interest in this research subject. Most studies have been published in the last four years. 80% of the approaches are history-based, that is, are based on the failure and test execution history. The great majority of studies report evaluation results by comparing prioritization techniques. The preferred measures are Time and number/percentage of Faults Detected. Few studies address CI testing problems and characteristics, such as parallel execution and test case volatility. Conclusions: We observed a growing number of studies in the field. Future work should explore other information sources such as models and requirements, as well as CI particularities and testing problems, such as test case volatility, time constraint, and flaky tests, to solve existing challenges and offer cost-effective approaches to the software industry.

지속적 통합 환경에서 회귀 테스트 기술의 비용효율성에 대한 실패 관심도 기반 분석

지속적 통합 환경에서 회귀 테스트 기술의 비용효율성에 대한 실패 관심도 기반 분석

Test prioritization in continuous integration environments

Two heuristics namely diversity-based (DBTP) and history-based test prioritization (HBTP) have been separately proposed in the literature. Yet, their combination has not been widely studied in continuous integration (CI) environments. The objective of this study is to catch regression faults earlier, allowing developers to integrate and verify their changes more frequently and continuously. To achieve this, we investigated six open-source projects, each of which included several builds over a large time period. Findings indicate that previous failure knowledge seems to have strong predictive power in CI environments and can be used to effectively prioritize tests. HBTP does not necessarily need to have large data, and its effectiveness improves to a certain degree with larger history interval. DBTP can be used effectively during the early stages, when no historical data is available, and also combined with HBTP to improve its effectiveness. Among the investigated techniques, we found that history-based diversity using NCD Multiset is superior in terms of effectiveness but comes with relatively higher overhead in terms of method execution time. Test prioritization in CI environments can be effectively performed with negligible investment using previous failure knowledge, and its effectiveness can be further improved by considering dissimilarities among the tests.