Arrhythmia refers to abnormalities of the heart rhythm, and it is considered a life-threatening pathology. Catheter ablation is a minimally invasive procedure which provides the best therapeutic outcomes to cure the arrhythmia. The procedure consists of a series of intraoperative and training challenges that could potentially affect the procedure outcome. This study examines how Extended Reality (XR) technologies (AR/VR) can be used to improve the cardiac catheter ablation procedure for electrophysiologists.

Pregnant women use a range of non-pharmacological pain relief methods to help manage and reduce pain intensity and to induce relaxation. We conducted a study with 18 pregnant women to explore VR experiences as a non-pharmacological method of pain relief to determine the effect on pain intensity. The results of the study identified several themes: evoking emotion with sub-themes, memory, and imagination. The theme presence, with sub-themes of relatability, realism, immersion, interactivity, and narration. Finally, the escape and anchoring themes were descriptions of how women envisaged using VR antenatally. This study provides a novel contribution to the field of VR and antenatal and labour care which can help inform the design of VR experiences for pregnant women.

Chronic pain is a continuous ailment lasting for long periods after the initial injury or disease has healed. Chronic pain is challenging to treat and affects the daily lives of patients. Distraction therapy is a proven method of relieving patients’ discomfort by taking their attention away from the pain. Virtual reality (VR) is a platform for distraction therapy by immersing the user in a virtual world detached from reality. However, there is little research on how physical interactions in VR affect pain management. We present a study to evaluate the effectiveness of physically active, mentally active, and passive interventions in VR using games with chronic pain patients. Our results indicate that physical and mental activities in VR are equally effective at reducing pain. Furthermore, These actively engage patients, while the effects of observing relaxing content persist outside VR. These findings can help inform the design of future VR games targeted at chronic pain management.

A clear and well-documented LaTeX document is presented as an article formatted for publication by ACM in a conference proceedings or journal publication. Based on the “acmart” document class, this article presents and explains many of the common variations, as well as many of the formatting elements an author may use in the preparation of the documentation of their work.

Highly configurable software, such as web browsers,databases or office applications, have a large number of preferences that the user can customize, but documentation of them may be scarce or distributed. A user, tester or service technician may have to search through hundreds or thousands of choices in multiple documents when trying to identify which preference will modify a particular system behavior. In this paper we present PrefFinder, a natural language framework that finds (and changes) user preferences. It is tied into an application's preference system and static documentation. We have instantiated PrefFinder as a plugin on two open source applications, and as a stand-alone GUI for an industrial application. PrefFinder finds thecorrect answer between 76-96% of the time on more than 175 queries. When compared to asking questions on a help forum or through the company's service center, we can potentially save days or even weeks of time.

Commercial static program analysis tools can be used to detect many defects that are common across applications. However, such tools currently have limited ability to reveal defects that are specific to individual projects, unless specialized checkers are devised and implemented by tool users. Developers do not typically exploit this capability. By contrast, defect mining tools developed by researchers can discover project-specific defects, but they require specialized expertise to employ and they may not be robust enough for general use. We present a hybrid approach in which a sophisticated dependence-based rule mining tool is used to discover project-specific programming rules, which are then transformed automatically into checkers that a commercial static analysis tool can run against a code base to reveal defects. We also present the results of an empirical study in which this approach was applied successfully to two large industrial code bases. Finally, we analyze the potential implications of this approach for software development practice.

Configurable systems that let users customize system behaviors are becoming increasingly prevalent. Testing a configurable system with all possible configurations is very expensive and often impractical. For a single version of a configurable system, sampling approaches exist that select a subset of configurations from the full configuration space for testing. However, when a configurable system changes and evolves, existing approaches for regression testing select all configurations that are used to test the old versions for testing the new version. As demonstrated in our experiments, this retest-all approach for regression testing configurable systems turns out to be highly redundant. To address this redundancy, we propose a configuration selection approach for regression testing. Formally, given two versions of a configurable system, S (old) and S' (new), and given a set of configurations CSfor testing S, our approach selects a subset CS'of CSfor regression testing S'. Our study results on two open source systems and a large industrial system show that, compared to the retest-all approach, our approach discards 15% to 60% of configurations as redundant. Our approach also saves 20% to 55% of the regression testing time, while retaining the same fault detection capability and code coverage of the retest-all approach.

Change impact analysis, i.e., knowing the potential consequences of a software change, is critical for the risk analysis, developer effort estimation, and regression testing of evolving software. Static program slicing is an attractive option for enabling routine change impact analysis for newly committed changesets during daily software build. However, static program slicing faces accuracy and scalability problems when applied routinely on large and evolving industrial software systems. In this paper, we present a tool called Imp, used within ABB, to address these problems. Imp transparently integrates with the version control and the daily build environments and is also available as a Visual Studio plugin for quick what-if analysis by developers for potential changes in software written in C/C++.

SUMMARY User‐configurable software systems present many challenges to software testers. These systems are created to address a large number of possible uses, each of which is based on a specific configuration. As configurations are made up of groups of configurable elements and settings, a huge number of possible combinations exist. As it is infeasible to test all configurations before release, many latent defects remain in the software once deployed. A just‐in‐time testing technique is presented to address this problem, including examples of how it can be used with various user‐configurable systems in the field. The proposed solution is evaluated with a set of five empirical studies conducted on two separate ABB software systems using real customer configurations and changes. These studies analyse failures reported by many different customers globally and show that this just‐in‐time testing process is effective at detecting latent defects exposed by customer configuration changes in user‐configurable systems. Copyright © 2010 John Wiley & Sons, Ltd.

Automatic testing, in particular test input generation, has become increasingly popular in the research community over the past ten years. In this paper, we conduct a survey on existing concolic testing tools, discussing their strengths and limitations, and environments in which they can be applied. We also conduct a case study to determine the prevalence of the identified limitations in six large software systems (four from open-source and two from ABB), as well as the effectiveness and scalability of the publicly available tools. The results show that pointers and native calls are the most prevalent limitations, preventing tools from generating high branch coverage lest eases, and variables of float type are the least prevalent. The scalability of the publically available tools is also a limitation for industrial use, due to the large overhead of creating a test harness. Finally, we propose suggestions on how practitioners can use these tools and how researchers can improve concolic testing.

Change impact analysis, i.e., knowing the potential consequences of a software change, is critical for the risk analysis, developer effort estimation, and regression testing of evolving software. Static program slicing is an attractive option for enabling routine change impact analysis for newly committed changesets during daily software build. For small programs with a few thousand lines of code, static program slicing scales well and can assist precise change impact analysis. However, as we demonstrate in this paper, static program slicing faces unique challenges when applied routinely on large and evolving industrial software systems. Despite recent advances in static program slicing, to our knowledge, there have been no studies of static change impact analysis applied on large and evolving industrial software systems. In this paper, we share our experiences in designing a static change impact analysis framework for such software systems. We have implemented our framework as a tool called Imp and have applied Imp on an industrial codebase with over a million lines of C/ C++ code with promising empirical results.

Testing configurable systems, which are becoming prevalent, is expensive due to the large number of configurations and test cases. Existing approaches reduce this expense by selecting or prioritizing configurations. However, these approaches redundantly run the full test suite for the selected configurations. To address this redundancy, we propose a test case selection approach by analyzing the impact of configuration changes with static program slicing. Given an existing test suite T used for testing a system S under a configuration C, our approach decides for each t in T if t has to be used for testing S under a different configuration C'. We have evaluated our approach on a large industrial system within ABB with promising results.

This paper presents an automatic technique for generating maintainable regression unit tests for programs. We found previous test generation techniques inadequate for two main reasons. First. they were designed for and evaluated upon libraries rather than applications. Second, they were designed to find bugs rather than to create maintainable regression test suites: the test suites that they generated were brittle and hard to understand. This paper presents a suite of techniques that address these problems by enhancing an existing unit test generation system. In experiments using an industrial system, the generated tests achieved good coverage and mutation kill score, were readable by the product's developers, and required few edits as the system under test evolved. While our evaluation is in the context of one test generator, we are aware of many research systems that suffer similar limitations, so our approach and observations are more generally relevant.

Collaboration between research groups can be quite difficult. Differences in hardware, software, and operating environments can lead to differences in results or even errors. Overcoming these difficulties can take significant time, or even result in ending the collaboration. A solution is presented and applied to two collaborations between ABB and universities. This collaboration involves using virtual machines as a way to create and deploy environments to each collaborator. The results show that this virtual machine solution allows for significant time savings in experimental setup. Also, collaborators are able to quickly reproduce results and remotely investigate any issues uncovered. Finally, this solution allows experiments to be rerun at later points in time without the need to recreate the environment.

Advances in software engineering have led to the creation of many new software engineering techniques. However, industrial adoption of these techniques is often quite low, as development organizations are skeptical of their value and applicability. Empirical studies are commonly used to show this value to potential adopters, with open source software used as an approximation of industrial applications. However, little data exists on the similarity of open source and industrial software. We present a large metrics-based study comparing the most commonly evaluated open source programs to a large set of industrial programs. Source metrics are calculated and compared between 24 open source and 21 industrial programs. The results identify open source programs that are most similar to industrial programs. Using these identified open source programs in empirical studies can provide the best generalization to industrial software.

Intermittent failures and nondeterministic behavior complicate and compromise the effectiveness of software testing and debugging. To increase the observability of software faults, we explore the effect hardware configurations and processor load have on intermittent failures and the nondeterministic behavior of software systems. We conducted a case study on Mozilla Firefox with a selected set of reported field failures. We replicated the conditions that caused the reported failures ten times on each of nine hardware configurations by varying processor speed, memory, hard drive capacity, and processor load. Using several observability tools, we found that hardware configurations that had less processor speed and memory observed more failures than others. Our results also show that by manipulating processor load, we can influence the observability of some faults.

Abstract While much is known about the appearance and human perception of emotional facial expressions, researchers and professionals experience difficulties when attempting to create believable animated characters. Methods for automating or capturing dynamic facial expressions have come on in leaps and bounds in recent years, resulting in increasingly realistic characters. However, accurate replication of naturalistic movement does not necessarily ensure authentic character performance. In this paper, the authors present a project which makes use of creative animation practices and artistic reflection as methods of research. The output of animation practice is tested experimentally by measuring observer perception and comparing the results with artistic observations and predictions. Ultimately, the authors aim to demonstrate that animation practice can generate new knowledge about dynamic character performance, and that arts‐based methods can and should be considered valuable tools in a field often dominated by technical methods of research. Copyright © 2010 John Wiley & Sons, Ltd.

Software quality improvement initiatives are frequently attempted inside major software development companies. These initiatives often face difficulty motivating managers and developers. Yet the success of these improvement initiatives is directly related to receiving support from them. A defect-driven improvement process is proposed, aiming to improve the adoption of techniques by these key groups. The process is based on using defect data to identify issues in the current development process. ABB has used this process to focus and motivate change in three major development organizations around the world. Results show that this process yields measurable improvements in organizations that have been reluctant to change in the past.

As software systems evolve, the size of their test suites grow due to added functionality and customer-detected defects. Many of these tests may contain redundant elements with previous tests. Existing techniques to minimize test suite size generally require dynamic execution data, but this is sometimes unavailable. We present a static technique that identifies test cases with redundant instruction sequences, allowing them to be merged or eliminated. Initial results at ABB show that 7%-23% of one test suite may be redundant.

User-configurable software systems present many challenges to software testers. These systems are created to address a large number of possible uses, each of which is based on a specific configuration. As configurations are made up of groups of configurable elements and settings, a huge number of possible combinations exist. Since it is infeasible to test all configurations before release, many latent defects remain in the software once deployed. An incremental testing process is presented to address this problem, including examples of how it can be used with various user-configurable systems in the field. The proposed solution is evaluated with a set of empirical studies conducted on two separate ABB software systems using real customer configurations and changes. The three case studies analyzed failures reported by many different customers around the world and show that this incremental testing process is effective at detecting latent defects exposed by customer configuration changes in user-configurable systems.

Missing or imprecise requirements can lead stakeholders to make incorrect assumptions. A "not a problem" defect report (NaP) describes a software behavior that a stakeholder regards as a problem while the developer believes this behavior is acceptable and chooses not to take any action. As a result, a NaP wastes the time of the development team because resources are spent analyzing the problem but the quality of the software is not improved. Performance requirements specification and analysis are instance-based. System performance can change based upon the execution environment or usage patterns. To understand how the availability and precision of performance requirements can affect NaP occurrence rate, we conducted a case study on an embedded control module. We applied the performance refinement and evolution model to examine the relationship between each factor in the performance requirements and the corresponding NaP occurrence rate. Our findings show that precise specification of subjects or workloads lowers the occurrence rate of NaPs. Precise specification of measures or environments does not lower the occurrence rate of NaPs. Finally, the availability of performance requirements does not affect NaP occurrence rate in this case study.

Abstract Testing firewalls have proven to be a useful approach for regression testing in both functional and object‐oriented software. They involve only the modules that are closely related to the changed modules. They lead to substantially reduced regression tests but still are very effective in detecting regression faults. This paper investigates situations when data‐flow paths are longer, and the testing of modules and components only one level away from the changed elements may not detect certain regression faults; an extended firewall considers these longer data paths. We report empirical studies that show the degree to which an extended firewall detected more faults, and how much more testing was required to achieve this increased detection. Copyright © 2008 John Wiley & Sons, Ltd.

Software products are often built from commercial-off-the-shelf (COTS) components. When new releases of these components are made available for integration and testing, source code is usually not provided by the vendors. Various regression test selection techniques have been developed and have been shown to be cost effective. However, the majority of these test selection techniques rely on source code for change identification and impact analysis. In our research, we have evolved a regression test selection (RTS) process called Integrated - Black-box Approach for Component Change Identification (I-BACCI) for COTS-based applications. I-BACCI reduces the test suite based upon changes in the binary code of the COTS component using the firewall regression test selection method. In this paper, we present the Pallino tool. Pallino statically analyzes binary code to identify the code change and the impact of these changes. Based on the output of Pallino and the original test suit, testers can determine the regression test cases needed to cover the application glue code which is affected by the changed areas in the new version of the COTS component. Three case studies, examining a total of fifteen component releases, were conducted on ABB internal products. With the help of Pallino, RTS via the I-BACCI process can be completed in about one to two person hours for each release of the case studies. The total size of application and component for each release is about 340 830 KLOC. Pallino is extensible and can be modified to support other RTS methods for COTS components. Currently, Pallino works on components in Common Object File Format or Portable Executable formats

Quantitatively-based risk management can reduce the risks associated with field defects for both software producers and software consumers. In this paper, we report experiences and results from initiating risk-management activities at a large systems development organization. The initiated activities aim to improve product testing (system/integration testing), to improve maintenance resource allocation, and to plan for future process improvements. The experiences we report address practical issues not commonly addressed in research studies: how to select an appropriate modeling method for product testing prioritization and process improvement planning, how to evaluate accuracy of predictions across multiple releases in time, and how to conduct analysis with incomplete information. In addition, we report initial empirical results for two systems with 13 and 15 releases. We present prioritization of configurations to guide product testing, field defect predictions within the first year of deployment to aid maintenance resource allocation, and important predictors across both systems to guide process improvement planning. Our results and experiences are steps towards quantitatively-based risk management.

ABB incorporates a variety of commercial-off-the-shelf (COTS) components in its products. When new releases of these components are made available for integration and testing, source code is often not provided. Various regression test selection processes have been developed and have been shown to be cost effectiveness. However, the majority of these test selection techniques rely on access to source code for change identification. In this paper we present the application of the lightweight Integrated - Black-box Approach for Component Change Identification (I-BACCI) Version 3 process that select regression tests for applications that use COTS components. Two case studies, examining a total of nine new component releases, were conducted at ABB on products written in C/C++ to determine the effectiveness of I-BACCI. The results of the case studies indicate this process can reduce the required number of regression tests at least 70% without sacrificing the regression fault exposure.

A testing firewall involves identifying various components that are dependent upon changed elements, but are just one level away from the modified elements. This paper investigates situations when data flow paths are longer, and the mechanism of thorough testing of components one level away from the changed elements may not detect certain regression faults caused by the change; this research has led to the notion of an extended firewall that takes these longer data paths into account. Empirical studies are reported that show the extent to which an extended firewall can detect more faults and how much more testing is required to achieve this increased detection.

Various regression test selection techniques have been developed and have shown to improve testing cost effectiveness via improving efficiency. The majority of these test selection techniques rely on access to source code for change identification. However, when new releases of COTS components are made available for integration and testing, source code is often not available to guide in regression test selection. In this paper we describe a lightweight integrated-black-box approach for component change identification (I-BACCI) process for selection of regression tests for user/glue code that uses COTS components. I-BACCI is applicable when component licensing agreements do not preclude binary code analysis. A case study of the process was conducted on an ABB product that uses a medium-scale internal ABB software component. Six releases of the component were examined to evaluate the efficacy of the proposed process. The result of the case study indicates that this process can reduce the required regression tests by 40% on average.

Industrial real-time systems are complex and need to be thoroughly tested before being released to the customer. We have found that last minute changes are often responsible for the introduction of defects, causing serious problems for the customer. We demonstrate that these defects can be introduced into real-time software in diverse ways, and there is no simple regression testing method that can deal with all of these defect sources. This paper describes the application of a testing firewall for regression testing whose form differs depending upon the defect. The idea of the testing firewall is to limit the regression testing to those potentially affected system elements directly dependent upon changed system elements, and then to thoroughly test these elements. This has resulted in substantial savings in regression testing costs, and yet has been effective in detecting critical defects with significant implication in terms of customer acceptance at ABB. Empirical studies are reported for these experiences in an industrial setting.