A cyber-physical system of systems (CPSoS) is a system composed of multiple constituent systems that interact with both physical and cyber environments. Self-adaptivity is essential for CPSoS because it works on both cyber and physical uncertainties in various environments. Main obstacles to achieving self-adaptive CPSoS are time constraints and system anomalies. An adaptation should be processed within a certain period and it should consider anomalies caused by system changes due to mechanical faults, cyber-attacks, or emergent behaviors. However, since existing adaptation approaches cannot fully handle both aspects, this paper proposes an advanced approach, A 4 , for a self-adaptive system that can handle known anomalies in runtime. This approach learns the known anomalies before runtime and mitigates their impact when they are detected. We evaluated the A 4 approach for virtual and physical CPSoS and showed that A 4 was more efficient than other approaches.

Energy efficiency is an important factor that mobile device designers must consider at the beginning of the design because the hardware is difficult to change once it is implemented. Many researchers have studied energy-efficient mobile designs, but not focused on actual mobile device usages. Verification on the energy efficiency of mobile device using actual usages is needed. However, two problems may arise in the verification based on mobile device usage: the difficulty in acquiring a large amount of usage data due to invasion of privacy, and the state explosion problem due to the amount of mobile device usage data. We propose statistical verification using learned usages that can overcome both problems to evaluate energy-efficient mobile device design. We generated thousands of learned usages based on 400 actual usages. The generated usages are given in verifying the target mobile device for energy efficiency, and the state explosion problem is bypassed using statistical verification. The verification results allow the designers to optimize the module with a high probability of being used or to evaluate whether the battery is used as expected.

Cyber-physical systems (CPSs) observe operational environments and continuously decide on actions to achieve goals. In many cases, complex CPSs have several goals to satisfy simultaneously. To develop a CPS with multiple goals, engineers can create various control systems, each contributing to a goal based on a system-of-systems (SoS) engineering perspective. Engineers then conduct field operational tests (FOTs) to collect data for analyzing and optimizing the control systems. However, uncertainties in the physical environment and the emergent behavior of multiple controllers present several challenges in conducting FOTs. We have hands-on experience in performing massive FOTs of a multi-controller CPS to realize engineering challenges in the FOTs. We modeled and developed an autonomous robot vehicle consisting of a lane-keeping system and an adaptive cruise control system. To analyze and optimize autonomous driving, we conducted FOTs of 125 possible configurations of the control systems, each 50 times. This paper presents 1) the model, software, and hardware implementation manuals of our case study on autonomous driving, 2) an FOT log dataset obtained from about 100 hours of driving and its analysis results, 3) research challenges emerging in the multi-controller CPS FOT learned from our hands-on experience, and 4) possible applications of our dataset for future research.

Autonomous systems (ASs) have design-level goals and, accordingly, strategies for achieving those goals. It requires systematic integration and guidance techniques to use their capabilities for collaborative work. Dealing with capability integration and decision guidance are some of the challenges considered in system of systems engineering (SoSE). We propose a simulation-based recommendation generation designed to influence the decision-making of ASs that are involved in a collaborative work. Towards this end, we have developed a JADE-based software module that can be used to simulate and analyze collaboration behaviors and decision patterns. The analysis results in a set of recommendations for actions that can be used to achieve collaborative tasks. In this paper, we present the application of the proposed approach to guide collaboration between ASs that participate in a high-rise building fire incident – a representative mass casualty incident response system. Based on the system simulation results, certain ASs show change in level of belonging to the collaborative work as a result of the recommended actions, which is considered as indicater to the better chance of achieving the SoS-level goal.

When operationally and managerially independent constituent systems are integrated to form a System of Systems (SoS), cybersecurity vulnerabilities can be exploited by cyber threats that can break the security requirements of SoS due to its collaborative nature. Using model-based testing to generate test cases automatically can potentially aid in discovering vulnerabilities. However, security test case generation is time-consuming, error-prone, and labor-intensive; therefore, it is desirable to fully or partially automate security testing processes. This paper proposes the automatic test data generation using formal models presented as communicating sequential processes. We use the model-checking technique that generates counterexamples when the specified security properties are violated. Our approach then converted those counterexamples into executable test data by applying the conversion rule and defined mapping algorithm. We demonstrate our approach with an experiment using an operation of an air traffic control (ATC) system, a representative of SoS. We developed an agent simulation program to test the operation of the ATC by using the generated test data and evaluating it in terms of vulnerability identification. We incorporated four attack types, and our experimental results show that the security tests generated from the models can identify the known vulnerabilities in the ATC system.

Since a System-of-Systems (SoS) is constructed and managed under a complex and dynamic environment, self-adaptability has become one of the key capabilities that SoSs should have. To design an adaptive SoS, analyzing and modeling the environment are important. Studies on self-adaptive systems (SAS) have proposed various analysis and design approaches to deal with dynamic environment and operating conditions. However, most existing approaches require a considerable amount of domain experts' knowledge about the operating environment without specific and practical guidelines, so there still remain many challenges for engineers to analyze and design an adaptive SoS. In this study, we propose a data-driven method of generating environment models for adaptive SoS. To guide the analysis and understanding of the environment, we propose a metamodel that encompasses characteristics of the dynamic environment. Based on the metamodel, an environment model is generated from historical data for effective analysis of the SoS's complex environment. As a case study, we apply our method to a traffic environment modeling with real data. We show that our proposed method can practically help engineers generate environment models with concrete features that are necessary for adaptive SoS modeling by considering the environment as a major entity for SAS analysis and design.

Empirical validation of software testing studies is increasingly relying on mutants. This practice is motivated by the strong correlation between mutant scores and real fault detection that is reported in the literature. In contrast, our study shows that correlations are the results of the confounding effects of the test suite size. In particular, we investigate the relation between two independent variables, mutation score and test suite size, with one dependent variable the detection of (real) faults. We use two data sets, CoreBench and Defects4J, with large C and Java programs and real faults and provide evidence that all correlations between mutation scores and real fault detection are weak when controlling for test suite size. We also find that both independent variables significantly influence the dependent one, with significantly better fits, but overall with relative low prediction power. By measuring the fault detection capability of the top ranked, according to mutation score, test suites (opposed to randomly selected test suites of the same size), we find that achieving higher mutation scores improves significantly the fault detection. Taken together, our data suggest that mutants provide good guidance for improving the fault detection of test suites, but their correlation with fault detection are weak.

Software remodularization seeks to cluster software modules with high cohesion and low coupling: such a structure can help the comprehension and maintenance of complex systems. The modularization quality is usually captured using either structural, semantic, or history-based factors. All existing techniques apply a single factor to the entire system, which raises the following issues. First, a single factor may fail to capture the quality across the entire project: some modules may form semantic bondings, while others may form more structural ones. Second, the user of the technique has to choose a factor without knowing which one would perform the best. To resolve these issues, we propose a multi-factor module clustering, in which module clusters can be formed based on different factors. Our technique not only allows module clusters of different natures, but also relieve users from having to select a single factor. The paper introduces two different search-based formulations of multi-factor remodularization, and compares these against single-factor remodularization using four heterogeneous factors and six open source projects. The evaluation results show that the multi-factor remodularization can produce solutions that are 10.69% closer to the actual modularization adopted by the developers as compared with those produced by single-factor remodularization on average.

Diversity has been widely studied in software testing as a guidance towards effective sampling of test inputs in the vast space of possible program behaviors. However, diversity has received relatively little attention in mutation testing. The traditional mutation adequacy criterion is a one-dimensional measure of the total number of killed mutants. We propose a novel, diversity-aware mutation adequacy criterion called distinguishing mutation adequacy criterion, which is fully satisfied when each of the considered mutants can be identified by the set of tests that kill it, thereby encouraging inclusion of more diverse range of tests. This paper presents the formal definition of the distinguishing mutation adequacy and its score. Subsequently, an empirical study investigates the relationship among distinguishing mutation score, fault detection capability, and test suite size. The results show that the distinguishing mutation adequacy criterion detects 1.33 times more unseen faults than the traditional mutation adequacy criterion, at the cost of a 1.56 times increase in test suite size, for adequate test suites that fully satisfies the criteria. The results show a better picture for inadequate test suites; on average, 8.63 times more unseen faults are detected at the cost of a 3.14 times increase in test suite size.

Data races are one of the most difficult types of bugs in concurrent multithreaded systems. It requires significant time and cost to accurately detect bugs in complex largescale programs. Although many race detection techniques have been proposed by various researchers, none of them are effective in all aspects. In this paper, we compare the performance of five recent dynamic race detection techniques: FastTrack, Acculock, Multilock-HB, SimpleLock+, and causally precedes (CP) detection. We experimentally demonstrate the strengths and weaknesses of these dynamic race detection techniques in terms of their detection capability, running time, and runtime overhead using 20 benchmark programs with different characteristics. The comparison results show that the detection capability of CP detection does not differ from that of FastTrack, and that SimpleLock+ generates the lowest overhead among the hybrid detection techniques (Acculock, SimpleLock+, and Multilock-HB) for all benchmark programs. SimpleLock+ is 1.2 times slower than FastTrack on average, but misses one true data race reported from Mutilock-HB on the large-scale benchmark programs.

The worldwide mobile software market has grown dramatically since feature phones became popular in the early 1990s. In practice, mobile usability — which can be defined for a resource-constrained device in two ways, namely, User eXperience (UX) and User Interface (UI) — has been regarded as the key to gaining superiority in terms of both market share and customer loyalty. Unfortunately, de facto standards for software design and the development process, such as Unified Modeling Language (UML) and Rational Unified Process (RUP), do not seem to promote mobile usability in a systematic manner in practice. This paper proposes a systematic and generalizable approach to modeling and evaluating the properties of mobile usability, herein treating it as a first-class software quality from the perspective of software engineering. We devise a UX evaluation framework for mobile usability, which we call UX Evaluation Framework (UEF) throughout this paper. A UX is specified by inter-scene interactions between users and terminals of software products using Extended Menu Navigation Viewpoints (EMNVs); then, a model checker, NuSMV, is adopted to observe whether the EMNV model meets a set of given UX properties. Importantly, the analysis and design of RUP is extended to support the co-design of UX and UI so that major roles, activities and artifacts in the UX and UI can be explicitly monitored and controlled by stakeholders. Through case studies, we demonstrate that UEF works properly to treat software products that prioritize mobile usability. Consequently, UEF plays a key role in filling the gap between two research disciplines to address usability: software engineering and human–computer interactions.

In the field of mutation analysis, mutation is the systematic generation of mutated programs (i.e., mutants) from an original program. The concept of mutation has been widely applied to various testing problems, including test set selection, fault localization, and program repair. However, surprisingly little focus has been given to the theoretical foundation of mutation-based testing methods, making it difficult to understand, organize, and describe various mutation-based testing methods. This paper aims to consider a theoretical framework for understanding mutation-based testing methods. While there is a solid testing framework for general testing, this is incongruent with mutation-based testing methods, because it focuses on the correctness of a program for a test, while the essence of mutation-based testing concerns the differences between programs (including mutants) for a test. In this paper, we begin the construction of our framework by defining a novel testing factor, called a test differentiator, to transform the paradigm of testing from the notion of correctness to the notion of difference. We formally define behavioral differences of programs for a set of tests as a mathematical vector, called a d-vector. We explore the multi-dimensional space represented by d-vectors, and provide a graphical model for describing the space. Based on our framework and formalization, we interpret existing mutation-based fault localization methods and mutant set minimization as applications, and identify novel implications for future work.

As Function Block Diagram (FBD) programs are used to implement safety-critical systems such as nuclear reactor protection systems, it is crucial to be able to generate effective test cases. The FBD is one of programming languages that are used for programmable logic controllers (PLCs). PLC programs are repeatedly run within a particular scan time for every execution. Among the constituents of FBD programs, function blocks and feedback variables use the inputs and outputs of the previous scan cycle on which to operate. Researchers have recently developed an automated test generation technique that satisfied several structural test coverage criteria for FBD programs using symbolic execution. However, their work could not generate test sequences for consecutive scan cycle but test inputs for one scan cycle. Test sequences are essential for testing FBD programs that have function blocks and feedback variables. This paper extends previous work in the field by generating test sequences for FBD programs with function blocks in a fully automated manner. The key technique involves explicitly unwinding FBD programs and solving test requirements using an SMT solver. We conduct experiments on increasing the coverage of test requirements by unwinding cycles and evaluating the effectiveness of the test set using mutation analysis with several subject programs, including a real-world reactor protection system. The experimental results show that the proposed approach is able to generate effective test sequences for FBD programs.

Fixing a non-deadlock concurrency bug is a difficult job that sometimes introduces additional bugs and requires a long time. To overcome this difficulty and efficiently perform fixing jobs, engineers should have broad knowledge of various fix patterns, and the ability to select the most proper one among those patterns based on quantitative data gathered from real-world bug databases. In this paper, we provide a real-world characteristic study on the fixes of non-deadlock concurrency bugs to help engineers responsible for program maintenance. In particular, we examine various fix patterns and the factors that influence the selection of those patterns with respect to the preexistence of locks and failure types. Our results will provide useful information for engineers who write bug patches, and researchers who study efficient testing and fixing techniques.

Many existing testing techniques adopt diversity as an important criterion for the selection and prioritization of tests. However, mutation adequacy has been content with simply maximizing the number of mutants that have been killed. We propose a novel mutation adequacy criterion that considers the diversity in the relationship between tests and mutants, as well as whether mutants are killed. Intuitively, the proposed criterion is based on the notion that mutants can be distinguished by the sets of tests that kill them. A test suite is deemed adequate by our criterion if the test suite distinguishes all mutants in terms of their kill patterns. Our hypothesis is that, simply by using a stronger adequacy criterion, it is possible to improve fault detection capabilities of mutation-adequate test suites. The empirical evaluation selects tests for real world applications using the proposed mutation adequacy criterion to test our hypothesis. The results show that, for real world faults, test suites adequate to our criterion can increase the fault detection success rate by up to 76.8 percentage points compared to test suites adequate to the traditional criterion.

Software planning is very important for the success of a software project. Even if the same developers work on the same project, the time span of the project and the quality of software may change based on the project plan. When software managers plan a software project, they strive to allocate human resources in a more efficient way to produce a better software with less cost. The planning process is, however, time-consuming and complicated, especially when the size of the software project is large.Many approaches have been proposed to help software project managers by providing optimal human resource allocations in terms of minimizing the cost. Previous approaches, however, only concentrated on minimizing the cost, and no existing works have considered the practical issues affecting project schedules in practice.We elicited the practical considerations relating to the human resource allocation problem through discussions with a group of software project experts. The practical considerations can affect the project schedule in practice, but their importance has not been taken into consideration in previous approaches. Reflecting the practical considerations, we propose an approach for solving the human resource allocation problem using a genetic algorithm (GA).We compare our approach to an approach that only considers minimization of the time span. Our evaluation shows that the proposed algorithm considers the practical considerations well, in terms of continuous allocation on relevant tasks, minimization of developer multitasking time, and balance of allocation. We also conducted a survey targeting software developers and managers, and the responses showed that practical considerations are as important as minimizing the cost, and our approach would be helpful to software managers. We also investigate the effect of weight factors and coefficient between sub-scores, and find that it is difficult to consider some practical considerations at the same time.

Software project planning includes several processes for estimating the effort required to complete software project tasks, allocating human resources to tasks, and creating a project plan. Because software planning is becoming more complicated as the size of software projects grow, it is difficult for project managers to decide on a reasonable project plan. To help them, many automatic software project planning approaches have been proposed. The approaches all focus on minimizing project duration. But if the plan is simply to minimize the duration, without considering software quality, the plan can harm the eventual software quality. In our research to create a reasonable project plan, we consider software quality as well as duration of the project, by defining a software quality score. The project manager can plan the project to maximize software quality for a specific project duration.

Software project planning is becoming more complicated and important as the size of software project grows. Many approaches have been proposed to help project managers by providing optimal staffing and scheduling in terms of minimizing the cost (i.e., necessary expanse) or time (i.e., time span or duration) required for the software project. Unfortunately, the software quality, another critical factor in software project planning, is largely overlooked in previous work. In this paper, we propose the quality based software project staffing and scheduling approach using a genetic algorithm (GA). We define a quality score by considering practical issues in software project planning in addition to task severity and defect amplification model. Further, the cost is utilized as a cost-bound in the GA to consider not only quality but also cost. Case study shows that the proposed approach improves the quality while the cost is optimized as the same as the cost-based approach. In other words, we provide better software project plans considering both cost and quality for software project managers. Also, we show the relationship between the quality and the cost in terms of software project planning.

A real-time system is a system wherein the behavior of the system depends not only on the input but also on the timing of the input. Timed automata is a widely used model for real-time system modeling and analysis. Model-based testing is employed to check whether the system under test (SUT) works according to the model specifications by using test cases generated from models that represent software requirements. In this paper, a case study was performed applying the timed automata based testing tools, UPPAAL-TRON, UPPAAL-COVER and SYMBOLRT, to the same system. Comparison of the testing approaches and tools is then made based on the results of the case study.

In this paper, we present a 10nm CMOS platform technology for low power and high performance applications with the tightest contacted poly pitch (CPP) of 64nm and metallization pitch of 48nm ever reported in the FinFET technology on both bulk and SOI substrates. A 0.053um2 SRAM bit-cell is reported with a corresponding Static Noise Margin (SNM) of 140mV at 0.75V. Intensive multi-patterning technology and various self-aligned processes have been developed with 193i lithography to overcome optical patterning limits. Multi-workfunction (MWF) gate stack has been enabled to provide Vt tunability without the variability degradation induced by Random Dopant Fluctuation (RDF) from channel dopants.