The increasing scale, distribution, and interconnection of software-intensive systems continue to change the landscape of software engineering research and practice, bringing the diffusion of two similar paradigms: Systems-of-Systems (SoS) and Software Ecosystems (SECO). SoS are characterized by the integration of operationally and managerially independent systems that join together to accomplish a common mission. SoS are central to domains such as transportation, healthcare, defense, smart cities, and industrial automation where heterogeneous systems must cooperate, exchange information, and adapt to evolving missions. On the other hand, SECO describe environments in which a platform and its surrounding network of developers, partners, and organizations co-create software offerings. In SECO, technical artifacts interact with economic and social processes. Modern digital platforms, mobile operating systems, cloud services, and enterprise platforms leverage the capabilities of their ecosystems. This editorial brings together perspectives that explore the shared challenges and complementary insights of SoS and SECO research, aiming to foster a richer understanding of complex software-intensive systems and highlight new opportunities for collaboration across communities. From the long-running, successful series of the International Workshop on Software Engineering for Systems-of-Systems and Software Ecosystems (SESoS), co-located with the IEEE/ACM International Conference on Software Engineering (ICSE), we present this special issue of the Journal of Systems and Software on the topics of SESoS 2024 in Lisbon, Portugal. From a total of 18 submissions, 7 articles were accepted in this special issue. The articles in this collection address fundamental questions of SoS and SECO, including the evolution of functional relations and experimentation practices, the key factors affecting developer experience, also related to women’s inclusion, as well as the adoption of GenAI-driven approaches for vulnerability fixing. These articles offer updates on current advances of SoS and SECO engineering to researchers and practitioners, highlighting opportunities for future research.

Abstract A cyber-physical system-of-systems (CPSoS) facilitates the achievement of high-level goals, such as efficient traffic management on roads, by designing and developing the collaboration of constituent CPSs. A platooning that groups autonomous vehicles in proximity is an example of collaboration. The intricate collaboration innately causes serious collaboration failures such as collisions. However, limited knowledge and complex dynamics of CPSoS cause several challenges in effectively analyzing the collaboration failures. Existing studies have applied pattern mining techniques to investigate various failures but have limitations when applied to collaboration failures: (1) absence of data model for continuous and discrete logs in CPSoS; (2) information loss problem by not considering the integrated relationship of the data; (3) dependence only on failed logs; (4) limited capability of fixed-size time windows. We propose a fuzzy clustering-based pattern mining approach that consists of a novel data model for CPSoS logs and comprehensive metrics for classifying and mining optimal collaboration failure patterns. In experiments on vehicle platooning, our approach exhibited the highest accuracy on pattern mining and clustering results. Further, we identified five collaboration failure scenarios in the empirical analysis of drone swarming results. The findings of this study can facilitate the effective analysis of CPSoS collaboration failures.

ABSTRACT For more than a decade, software engineering for systems‐of‐systems (SoS) and software ecosystems (SECO) has been largely investigated in order to cope with complexity in software‐intensive systems. SoS research addresses several aspects related to software system architecture comprising a set of constituent systems that relate to each other to perform missions. As such, SoS have key characteristics such as operational and managerial independence, distribution, emergent behavior, and evolutionary development. Full interoperability and dynamic architecture become critical challenges in this context. On the hand, SECO research refers to modeling and analysis of a socio‐technical network of actors and artifacts formed on top of common technological platforms, in which business factors directly influence software maintenance and evolution. Software sustainability and diversity as well as quality attributes that affect the SECO platform health represent challenges in the field. From the long‐running, successful series of the International Workshop on Software Engineering for systems‐of‐systems and Software Ecosystems (SESoS), co‐located with the IEEE/ACM International Conference on Software Engineering (ICSE), we present this special issue on the topics in the Journal of Software: Evolution and Process from SESoS 2023 in Melbourne, Australia. Four articles were accepted and published in this special issue, covering a longitudinal analysis of SoS research, as well as strategic patterns, services, and trust in SECO. These articles provide researchers and practitioners with advances in the state of the art and point out opportunities for further research.

Scenario-based techniques, also known as scenario methods, have been actively employed to resolve intricate problems for engineering complex software systems. Scenarios are powerful tools that allow engineers to analyze the dynamics and contexts of complex systems. Despite the widespread use, there is a lack of a well-established reference framework that systematically organizes key concepts and attributes of scenarios. This has left engineers without a systematic guidance at the method level, hindering their ability to utilize the scenario methods effectively. To address the challenges associated with scenario methods, this study aims to provide a reference framework and modeling method. By conducting a literature review and suggesting a Conceptual Scenario Framework (CSF), we establish a conceptual basis that systematically presents the core concepts and characteristics of scenarios. Additionally, we introduce the Extensible Scenario Modeling Method (ESMM) that empowers engineers to perform scenario modeling and domain-specific extensions using the framework. With the inclusion of the Extensible Scenario Modeling Language (ESML), which comprises domain-general model types and classes for scenario description and ontological analysis, ESMM facilitates flexible design of domain-specific scenario elements through language-level extensions. This study assesses the proposed method in comparison to existing scenario development methods in the automated driving system domain. Through an analysis of their ability to represent scenario data, it was established that the language constructs of ESML possess semantic expressiveness suitable for serving as a reference framework. Furthermore, the findings from the case study validate the extensibility of ESMM for specialization in creating a scenario modeling language tailored to specific domains, while also effectively supporting the ontological analysis of particular application domains.

Cyber-Physical Systems (CPS) continuously interact with their physical environments through embedded software controllers that observe the environments and determine actions. Field Operational Tests (FOT) are essential to verify to what extent the CPS under analysis can achieve certain CPS goals, such as satisfying the safety and performance requirements, while interacting with the real operational environment. However, performing many FOTs to obtain statistically significant verification results is challenging due to its high cost and risk in practice. Simulation-based verification can be an alternative to address the challenge, but it still requires an accurate virtual environment model that can replace the real environment interacting with the CPS in a closed loop. In this article, we propose ENVI (ENVironment Imitation), a novel approach to automatically generate an accurate virtual environment model, enabling efficient and accurate simulation-based CPS goal verification in practice.To do this, we first formally define the problem of the virtual environment model generation and solve it by leveraging Imitation Learning (IL), which has been actively studied in machine learning to learn complex behaviors from expert demonstrations. The key idea behind the model generation is to leverage IL for training a model that imitates the interactions between the CPS controller and its real environment as recorded in (possibly very small) FOT logs. We then statistically verify the goal achievement of the CPS by simulating it with the generated model. We empirically evaluate ENVI by applying it to the verification of two popular autonomous driving assistant systems. The results show that ENVI can reduce the cost of CPS goal verification while maintaining its accuracy by generating accurate environment models from only a few FOT logs. The use of IL in virtual environment model generation opens new research directions, further discussed at the end of the article.

Programmable logic controllers (PLCs) are widely used for process control and automation in safety-critical systems, such as reactor protection systems (RPS) in nuclear power plants. Industrial systems are often composed of multiple PLCs and have several interfaces with other systems. It is crucial to test PLC programs for such systems effectively. As manual integration testing is costly and time-consuming, simulation- based testing is becoming more important in validating safety- critical systems. However, simulation-based testing is limited because the simulation execution results may differ from the real PLC program execution results. This study presents the PLC synchronization method and multiple PLCs execution method for the Automated Simulation-based Integrated Testing approach (ASIT). MultiPLCTester is a test tool we developed to support ASIT and it executes test inputs with a simulation model and communicates with a PLC and compares them with execution results. Based on the synchronized test execution results, it con-ducts ASIT for target systems. We performed experiments using real industrial cases to evaluate the effectiveness and efficiency of our approach. The test suite execution time using ASIT was significantly reduced compared to the manual integration testing. When considering the test execution time and the cost of building a test bed, ASIT provides effective and efficient integrated testing for PLC testers.

A Cyber-Physical System-of-Systems (CPSoS) has innate uncertainties from operation in the physical environment and interaction among the constituent systems. These uncertainties make a CPSoS more susceptible to the oracle problem, a challenge in determining the correct behavior when testing the system. Metamorphic testing (MT) suggests a solution to addressing this challenge by utilizing metamorphic relations (MRs), relations among multiple inputs and corresponding outputs of the system. However, when applying MT on a CPSoS, generating MRs is difficult due to the continuous operation of a CPSoS in uncertain environment. In this study, we propose a method to automatically generate MRs from field operational test (FOT) data logs of a CPSoS. We define an MR template to capture the CPSoS behaviors. We then apply genetic algorithm to adapt the MR generated by the engineers, and thus improve the testing effectiveness. Our method is validated in a case study of an autonomous robot vehicle. Our results show that the automatically generated MRs capture the behaviors of a CPSoS more realistically than the manually generated MRs. With our method, engineers can obtain CPSoS MRs with minimal manual effort.

Summary Function block diagram (FBD) is a standard programming language for programmable logic controllers (PLCs). PLCs have been widely used to develop safety‐critical systems such as nuclear reactor protection systems. It is crucial to test FBD programs for such systems effectively. This paper presents an automated test sequence generation approach using mutation testing techniques for FBD programs and the developed tool, MuFBDTester. Given an FBD program, MuFBDTester analyses the program and generates mutated programs based on mutation operators. MuFBDTester translates the given program and mutants into the input language of a satisfiability modulo theories (SMT) solver to derive a set of test sequences. The primary objective is to find the test data that can distinguish between the results of the given program and mutants. We conducted experiments with several examples including real industrial cases to evaluate the effectiveness and efficiency of our approach. With the control of test size, the results indicated that the mutation‐based test suites were statistically more effective at revealing artificial faults than structural coverage‐based test suites. Furthermore, the mutation‐based test suites detected more reproduced faults, found in industrial programs, than structural coverage‐based test suites. Compared to structural coverage‐based test generation time, the time required by MuFBDTester to generate one test sequence from industrial programs is approximately 1.3 times longer; however, it is considered to be worth paying the price for high effectiveness. Using MuFBDTester, the manual effort of creating test suites was significantly reduced from days to minutes due to automated test generation. MuFBDTester can provide highly effective test suites for FBD engineers.

System of Systems (SoS), refers to a class of systems that are comprised of independent constituent systems (CS) interacting with one another to form a larger system, thus resulting in a common goal being achieved through the set of interactions between the CSs. In conventional systems software testing, the problem of identifying correct behaviour given a set of test inputs is called the oracle problem. In terms of SoS, the oracle problem is exacerbated due to each CS in an SoS being sufficiently complex systems themselves. We address the oracle problem in the domain of the software testing in System of Systems (SoS) by applying Metamorphic Testing (MT). In order to derive concrete Metamorphic Relations (MR) for SoS, we first borrow the concept of creating MRs from abstract Metamorphic Relation Patterns (MRPs), where the represented MRPs themselves describe characteristics that are used in the modeling and analysis of SoS. They are then applied to two SoS simulator types, the Smart Grid SoS and Mass Casualty Incident (MCI) Response SoS in order to test for reliability in SoS and to also determine the viability of MT in SoS. It is shown through the experiments conducted that the derived concrete MRs are able to find faults in both the systems under test.

The runtime environment is an important concern for self-adaptive systems (SASs). Although researchers have proposed many approaches for developing SASs that address the issues from runtime environments, the understanding of these environments varies depending on the objectives, perspectives, and assumptions of the research. Thus, the current understanding of environments in SAS development remains ambiguous and abstract. To make this knowledge more concrete, we investigated concepts and models of the environment covered in this area through a systematic literature review (SLR). We automatically and manually searched 3719 papers and selected 128 papers as primary studies. We explored and analyzed concepts of the environment covered in the primary studies and investigated cases in which the concepts were specifically expressed as environment models. In doing so, we provide trends of how SAS academia understands the environment of SAS. Specifically, this SLR provides five common characteristics of the environment, two common sources of the environmental uncertainty, and 14 reference environment models with various purpose and expressiveness. Finally, we summarized lessons learned through this SLR and directions for future SAS research on the basis of the concrete knowledge of the SAS environment.

Abstract Proactive adaptation, in which the adaptation for a system’s reliable goal achievement is performed by predicting changes in the environment, is considered as an effective alternative to reactive adaptation, in which adaptation is performed after observing changes. When predicting the environmental changes, the prediction may be uncertain, so it is necessary to verify and confirm an adaptation’s consequences before execution. To resolve the uncertainty, probabilistic model checking (PMC) has been utilized for verification of adaptation tactics’ effects on the goal of a self-adaptive system (SAS). However, PMC-based approaches have limitations on the state-explosion problem of complex SAS model verification and the modeling languages supported by the model checkers. In this paper, to overcome the limitations of the PMC-based approaches, we propose an efficient Proactive Adaptation approach based on STAtistical model checking (PASTA). Our approach allows SASs to mitigate the uncertainty of the future environment, faster than the PMC-based approach, by producing statistically sufficient samples for verification of adaptation tactics based on statistical model checking (SMC) algorithms. We provide algorithmic processes, a reference architecture, and an open-source implementation skeleton of PASTA for engineers to apply it for SAS development. We evaluate PASTA on two SASs using actual data and show that PASTA is efficient comparing to the PMC-based approach. We also provide a comparative analysis of the advantages and disadvantages of PMC- and SMC-based proactive adaptation to guide engineers’ decision-making for SAS development.

In recent years, a domain of Systems-of-Systems (SoS) has emerged due to the needs of utilizing collective and collaborative system capabilities. As interest in SoS engineering has grown, this study focuses on the model-based analysis and design of an SoS, and we propose a general-purpose modeling method for the model-based SoS engineering (MBSoSE). Based on requirements that modeling methods of MBSoSE approaches should fulfill, required model types are identified (19 model types) and they are classified on their different modeling purposes and concerns (6 model categories). Model types are meta-modeled using the ADOxx Metamodeling Platform and they are implemented as modeling languages in a tool, called SIMVA-SoS Modeler. Using the modeling tool developed, we designed two different SoS cases and their scenarios that can be utilized as inputs of simulation and verification tools. Through the case studies, overall applicability of our modeling method for MBSoSE is evaluated and specific modeling results are provided as base reference models.

Interactions between software components play a major role in the achievement of goals in complex systems, such as platooning System-of-Systems (SoS). A platooning SoS groups vehicles in order to increase their fuel efficiency and alleviates traffic congestion by enabling driving in close proximity using operation protocols. In a platooning SoS, the execution of typical operations, such as Leave or Merge, consists of 20 micro-operations on average. Owing to this overabundance of sub-operations, interaction failures in a specific operation sequence can occur in an SoS execution. Further, analyzing the root cause of such failures is highly time-consuming, due to the density of the constituent interactions. Existing techniques suffer from two limitations: (1) The majority of the root cause analysis techniques are not capable of isolating faulty interaction sequences, because they do not directly utilize interaction data; (2) The majority of the fault diagnosis techniques assume the preexamined fault knowledge base, which needs too high cost due to limited knowledge in an SoS. To effectively analyze interaction failures in an SoS, we propose a pattern-based faulty interaction analysis technique. To this end, an interaction model is first defined for an SoS, followed by the proposal of a suspicious interaction pattern mining algorithm. During the case study using a platooning simulator, the technique automatically abstracts interaction data from logs and extracts faulty interaction patterns, thereby enabling the identification of seven new unreported interaction failure scenarios. The conclusions of this study can enrich the general fault knowledge base for platooning SoS.

Platooning system is a well-known technology for alleviating traffic congestion and increasing fuel efficiency by grouping vehicles. It has the major characteristics of Systems of Systems (SoS), such as uncertainty. Several internal and external factors of uncertainty exist in the platooning system, such as car accidents, network disconnections, and simultaneous requests from other platoons. These factors make it difficult to guarantee that the system operates correctly in unpredictable scenarios and environments. The existing techniques used to verify the platooning system have two limitations: 1) the lack of consideration of uncertainty in scenarios and environments; 2) the application of exhaustive verification techniques which are vulnerable to the state-explosion problem. Thus, we suggest a statistical verification framework for a platooning SoS to address the above two limitations. The proposed framework automatically generates platooning configurations and scenarios with internal and external uncertain factors considered, and bypasses the state-explosion problem using a statistical verification technique. In this study, experimental results showed that the proposed approach generates 50% more valid scenarios than pure random strategy. In addition, we found two types of undiscovered failures and their causes in the VENTOS platooning system. These results indicate that our approaches enable the deep analysis of the platooning management system.

Summary In this paper, we propose a new test case prioritization technique that combines both mutation‐based and diversity‐aware approaches. The diversity‐aware mutation‐based technique relies on the notion of mutant distinguishment, which aims to distinguish one mutant's behaviour from another, rather than from the original program. The relative cost and effectiveness of the mutation‐based prioritization techniques (i.e., using both the traditional mutant kill and the proposed mutant distinguishment) are empirically investigated with 352 real faults and 553,477 developer‐written test cases. The empirical evaluation considers both the traditional and the diversity‐aware mutation criteria in various settings: single‐objective greedy, hybrid, and multi‐objective optimization. The results show that there is no single dominant technique across all the studied faults. To this end, the reason why each one of the mutation‐based prioritization criteria performs poorly is discussed, using a graphical model called Mutant Distinguishment Graph that demonstrates the distribution of the fault‐detecting test cases with respect to mutant kills and distinguishment. © 2018 John Wiley & Sons, Ltd.

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.

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.

A System-of-Systems (SoS) is a collection of systems, which consists of independent constituent systems to achieve higher-level goals. As an SoS changes constantly due to external and internal factors, dynamic reconfiguration and evolutionary development must be performed effectively. To manage an SoS that has these characteristics, SoS managers and engineers need to model and verify an SoS that accommodates changes. While many researchers have proposed techniques for modeling and verifying an SoS, little attention has been paid to the verification of a continuously changing SoS. Since the size and complexity of SoSs are too great to apply existing verification techniques, an efficient verification method for dynamically changing SoSs is required. If we can detect the change-related goals of an SoS and the corresponding change-affected parts in an SoS model, we can slice the SoS model in our area of concern and verify the SoS model efficiently. This paper proposes SoS GaP slicer, a verification method that considers the dynamic reconfiguration and evolution of an SoS. Our method could save the cost of verifying the whole of an SoS model by an efficient statistical model checking for SoSs. The experimental results show the accuracy and efficiency of the proposed method.

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.

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.

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.

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.

Automated Graphical User Interface (GUI) testing is one of the most widely used techniques to detect faults in mobile applications (apps) and to test functionality and usability. GUI testing exercises behaviors of an application under test (AUT) by executing events on GUIs and checking whether the app behaves correctly. In particular, because Android leads in market share of mobile OS platforms, a lot of research on automated Android GUI testing techniques has been performed. Among various techniques, we focus on model-based Android GUI testing that utilizes a GUI model for systematic test generation and effective debugging support. Since test inputs are generated based on the underlying model, accurate GUI modeling of an AUT is the most crucial factor in order to generate effective test inputs. However, most modern Android apps contain a number of dynamically constructed GUIs that make accurate behavior modeling more challenging. To address this problem, we propose a set of multi-level GUI Comparison Criteria (GUICC) that provides the selection of multiple abstraction levels for GUI model generation. By using multilevel GUICC, we conducted empirical experiments to identify the influence of GUICC on testing effectiveness. Results show that our approach, which performs model-based testing with multi-level GUICC, achieved higher effectiveness than activity-based GUI model generation. We also found that multi-level GUICC can alleviate the inherent state explosion problems of existing a single-level GUICC for behavior modeling of real-world Android apps by flexibly manipulating GUICC.

Multithreading is a widely used programming technique that efficiently uses multicore processors. However, correctly executing a multithreaded program is challenging mainly because of intractable concurrency bugs caused by nondeterministic thread scheduling. Data races are one of the main causes of those concurrency bugs, and data race detectors are essential tools to assist long-suffering programmers in locating data races in problematic multithreaded programs. In this paper, we propose a new hybrid detector called SimpleLock+, which accurately detects data races in a scheduling-insensitive manner with a low runtime overhead by combining happens-before and simplified Lockset algorithms. We significantly reduce the runtime slowdowns of previous hybrid detectors by assuming that most data races are caused by accesses to a shared memory location without the protection of locks and that the distance between accesses that cause a data race is not long in an execution trace. In addition, we improve the speed of the detection algorithm by using a simpler data structure and by eliminating redundant operations. The results of the experiments that are conducted on the RoadRunner framework confirm that those assumptions are valid and that the SimpleLock+ detector can efficiently and accurately detect real and potential data races that are caused by inconsistent locking in one execution trace. The results also show that the average runtime slowdown of SimpleLock+ is only 1.09 times that of FastTrack, which is the fastest happens-before race detector, and SimpleLock+ reports the same race warnings with one missing data race as the current accurate hybrid detector.

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.

Collective adaptive systems (CAS) consist of multiple agents that adapt to changing system and environmental conditions in order to satisfy system goals and quality requirements. As more applications involve using CAS in a critical context, ensuring the correct and safe adaptive behaviors of quality-driven CAS has become more important. In this paper, we propose Collective Adaptive System Testing (CAST), a scalable and efficient approach to testing self-adaptive behaviors of CAS. We propose a selective method to instantiate and execute test cases relevant to the current adaptation context. This enables testers to focus testing on key self-adaptive behaviors while dealing with the scale and dynamicity of the system. An experimental evaluation using a traffic monitoring system is performed to validate its scalability, efficiency, and fault-detection effectiveness. The experimental results provide insights into how CAST can serve as a feasible and effective assurance technique for CAS.

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.

For automating refactoring identification, previous methods for assessing the impact of a large number of refactoring candidates may be computationally expensive. In our paper, we propose an efficient method for assessing the impact of refactoring candidates on maintainability based on matrix computation, which is approximate but fast. This proposed method is evaluated on a refactoring identification approach for Edit and Columba, two large-scale open source projects. The experiments show that the proposed method requires less time for assessing refactoring candidates and that the refactoring identification approach using our proposed method also improves maintainability.

Since studies based on mining software repositories sparked interests in the field of guiding software changes, many change recommendation techniques have been proposed to reduce omission errors. While these techniques only used existing software commit data sets to evaluate their effectiveness, we use the data set of supplementary patches which correct initial incomplete patches to investigate how much actual omission errors could be prevented in practice. We find that while a single trait is inadequate, combining multiple traits is limited as well for predicting supplementary change locations. Neither does a boosting approach improve accuracy significantly, nor filtering based on developer or package specific information necessarily improves the accuracy. Developers rarely repeat the same mistakes, making the potential value of history-based change prediction less promising. We share our skepticism that omission errors are hard to prevent in practice based on a systematic evaluation of a supplementary patch data set.

SUMMARY Automated and effective testing for function block diagram (FBD) programs has become an important issue, as FBD is increasingly used in implementing safety‐critical systems. This work describes an automated test case generation technique for FBD programs and its associated tool—FBDTester. Given an FBD program and desired test coverage criteria, FBDTester generates test requirements and invokes the Satisfiability Modulo Theories solver iteratively to derive a set of test cases. An industrial case study using reactor protection system software shows that the automatically generated test suites detected at least 82% of the known faults, whereas manually generated test cases only detected approximately 35%. Mutation analysis revealed that the automatically generated test suites substantially outperformed manually generated ones. Although test sequence generation requires some manual effort in the current FBDTester, it is apparent that the proposed approach significantly improves the efficiency and the reliability of FBD testing. Copyright © 2014 John Wiley & Sons, Ltd.

Data races are one of the major causes of concurrency bugs in multithreaded programs, but they are hard to find due to nondeterministic thread scheduling. Data race detectors are essential tools that help long-suffering programmers to locate data races in multithreaded programs. One type of detectors precisely detects data races but is sensitive to thread scheduling, whereas another type is less sensitive to thread scheduling but reports a considerable number of false positives. In this paper, we propose a new dynamic data race detector called SimpleLock that accurately detects data races in a scheduling insensitive manner with low execution overhead. We reduce execution overhead by using two assumptions. The first is that most data races are caused by the accessing of shared variables without locks. The second is that two accesses that cause a data race have not a long distance between them in an execution trace. The results of experiments conducted on the Road Runner framework confirm that these assumptions are valid and that our SimpleLock detector can efficiently and accurately detect real and potential data races in one execution trace. The results also indicate that the execution overhead of SimpleLock is not much higher than that of FastTrack, the fastest happens-before race detector.

Many software systems rely on graphical-user interfaces (GUIs) to support user interactions. The correctness of these GUIs affects the overall quality of the systems, and thus, it is important that GUIs be tested. To support such testing, GUI test case generation techniques based on graph models such as event flow graphs (EFGs) have been used to generate test cases in the form of sequences of events. Models, however, are abstractions of dynamic behavior and may not accurately reflect actual system behavior, thus, test case generation techniques based on models may create nonexecutable test cases and miss important events. Test case generation techniques based on dynamic event extraction-based approaches, in contrast, may suffer less from these effects. As a consequence, we expect that the two approaches will differ in terms of cost and effectiveness. In this paper, we report the results of an empirical study comparing the cost and effectiveness of model-based and dynamic event extraction-based test case generation approaches. Our results show that event extraction-based approaches, though more expensive than model-based approaches, are indeed more effective in terms of their ability to achieve code coverage and to cover events, but at additional cost, with implications for both researchers and practitioners.

A recent study finds that errors of omission are harder for programmers to detect than errors of commission. While several change recommendation systems already exist to prevent or reduce omission errors during software development, there have been very few studies on why errors of omission occur in practice and how such errors could be prevented. In order to understand the characteristics of omission errors, this paper investigates a group of bugs that were fixed more than once in open source projects - those bugs whose initial patches were later considered incomplete and to which programmers applied supplementary patches. Our study on Eclipse JDT core, Eclipse SWT, and Mozilla shows that a significant portion of resolved bugs (22% to 33%) involves more than one fix attempt. Our manual inspection shows that the causes of omission errors are diverse, including missed porting changes, incorrect handling of conditional statements, or incomplete refactorings, etc. While many consider that missed updates to code clones often lead to omission errors, only a very small portion of supplementary patches (12% in JDT, 25% in SWT, and 9% in Mozilla) have a content similar to their initial patches. This implies that supplementary change locations cannot be predicted by code clone analysis alone. Furthermore, 14% to 15% of files in supplementary patches are beyond the scope of immediate neighbors of their initial patch locations - they did not overlap with the initial patch locations nor had direct structural dependencies on them (e.g. calls, accesses, subtyping relations, etc.). These results call for new types of omission error prevention approaches that complement existing change recommendation systems.

Abstract Resource allocation in a software project is crucial for successful software development. Among various types of resources, human resource is the most important as software development is a human‐intensive activity. Human resource allocation is very complex owing to the human characteristics of developers. The human characteristics affecting allocation can be grouped into individual‐level characteristics and team‐level characteristics. At the individual level, familiarity with tasks needs to be taken into account as it affects the performance of developers. In addition, developers have different levels of productivity, depending on their capability and experience; the productivity of developers also varies according to tasks. At the team level, characteristics such as team cohesion, communication overhead, and collaboration and management also affect human resource allocation. As these characteristics affect the efficiency of project execution, we treat them as constraints of human resource allocation in our approach. We identify individual‐level constraints and team‐level constraints based on the literature and interviews with experts in the industry. With these constraints, our approach optimizes the scheduling of human resource allocations, resulting in more realistic and efficient allocations. We also provide a guideline supporting various factors, with respect to roles and module characteristics, to estimate the productivity of developers based on COCOMO II. As productivity data are hard to obtain and manage, our guideline can provide a useful direction for human resource allocation in case of software projects. To validate our proposed approach, we document a case study using real project data. Copyright © 2011 John Wiley & Sons, Ltd.

Abstract Refactoring is a widely accepted technique to improve the software quality by restructuring its design without changing its behavior. In general, a sequence of refactorings needs to be applied until the quality of the code is improved satisfactorily. In this case, the final design after refactoring can vary with the application order of refactorings, thereby producing different quality improvements. Therefore, it is necessary to determine a proper refactoring schedule to obtain as many benefits as possible. However, there is little research on the problem of generating appropriate schedules to maximize quality improvement. In this paper, we propose an approach to automatically determine an appropriate schedule to maximize quality improvement through refactoring. We first detect code clones that are suitable for refactoring and generate the most beneficial refactoring schedule to remove them. It is straightforward to select the best from the exhaustively enumerated schedules. However, such a technique becomes NP‐hard, as the number of available refactorings increases. We apply a genetic algorithm (GA) to generate the best refactoring schedule within a reasonable time to cope with this problem. We compare the GA‐based approach with manual scheduling, greedy heuristic‐based, and exhaustive approaches for four open systems. The results show that the proposed GA‐based approach generates more beneficial schedules than the others. Copyright © 2010 John Wiley & Sons, Ltd.

Poorly designed software systems are one of main causes of accidents in safety-critical systems, and thus, the importance of safety analysis for software has greatly increased over the recent years. Software safety can be improved by analyzing both its desired and undesired behaviors, and this in turn requires expressive power such that both can be modeled. However, there is a considerable gap between modeling methods for desired and undesired behaviors. Therefore, we propose a method to bridge the gap between fault trees (for undesired behavior) and UML state machine diagrams (for desired behavior). More specifically, we present rules and algorithms that facilitate the transformation of a hazard (in the context of fault trees) to a UML state machine diagram. We illustrate our proposed approach via an example on a microwave-oven system. Our proposed transformation can help engineers identify how the hazards may occur, thereby allowing them to prevent the hazard from occurring.

Accurate software effort estimation is essential for successful project management. To improve the accuracy, a number of estimation techniques have been developed. Among those, Analogy-Based Estimation (ABE) has become one of the mainstreams of effort estimation. In general, ABE infers the effort to accomplish a new project from the efforts of the historical projects which possess similar characteristics. ABE is simple, yet it can be affected by the noise in historical projects. Noise is generally the data corruptions which may cause negative affect on the performance of a model built on the historical data. In this study, we propose an approach to filtering noise in the historical projects to improve the accuracy of ABE. We introduce and measure the Effort-Inconsistency Degree (EID), the degree that the effort of a historical project is inconsistent from those of its similar projects. Based on EID, we identify and filter the noise in terms of the inconsistent historical project data. We have validated the performance of ABE with our approach and three representative filtering techniques, namely the Edited Nearest Neighbor algorithm, the Univariate Outlier Elimination, and the Genetic Algorithm based project selection, on three software project datasets (Desharnais, Maxwell, and ISBSG (International Software Benchmarking Standards Group) Telecom). The experimental results suggest that our approach can improve the accuracy of ABE more effectively than can the other approaches.

Accurate software effort estimation is one of the key factors to a successful project by making a better software project plan. To improve the estimation accuracy of software effort, many studies usually aimed at proposing novel effort estimation methods or combining several approaches of the existing effort estimation methods. However, those researches did not consider the distribution of historical software project data which is an important part impacting to the effort estimation accuracy. In this paper, to improve effort estimation accuracy by least squares regression, we propose a data partitioning method by the accuracy measures, MRE and MER which are usually used to measure the effort estimation accuracy. Furthermore, the empirical experimentations are performed by using two industry data sets (the ISBSG Release 9 and the Bank data set which consists of the project data performed in a bank in Korea).

The implied scenarios are unexpected behaviors in the scenario specifications. Detecting and handling them is essential for the correctness of the scenario specifications. Prior researches focus on detecting those implied scenarios through error traces, and cannot identify where to be considered to handle the implied scenarios. Moreover, most of them do not consider the asynchronous communication style although the implied scenarios may vary according to communication styles. In this paper, we provide a graph based approach to detecting causes of implied scenarios under the asynchronous and synchronous communication styles. The semantics of the scenario specification is defined as a partially ordered set which is represented as a graph. Based on the graph, our approach constructs another graph which represents behaviors of a minimal implementation satisfying the scenario specification. Differentiating between the two graphs identify which part of the scenario specification causes the implied scenarios under the asynchronous communication style. In addition, our approach can be also applied under the synchronous communication styles by adding additional relationships to the two graph. To validate our approach, we provide two case studies.

Reuse of the software development process and its knowledge and experiences is a critical factor for the success of the software project. On the other hand, the software development process needs to be tailored to reflect the specific characteristics of the software project. So, if we can retrieve a similar process to a new project, process tailoring will be less costly and less error-prone because the retrieved process can be tailored to the new case with fewer modifications. In this paper, we propose the case retrieval method based on structural similarity. The structural similarity is calculated by the degree that process elements in a past case are applicable to a new project. By measuring the structural similarity, the retrieved process is ensured to be tailored to the new case with fewer modifications. We validate the usefulness of our method through the experiments using 30 cases.

During the development and maintenance of object-oriented (OO) software, the information on the classes which are more prone to be changed is very useful. Developers and maintainers can make a more flexible software by modifying the part of classes which are sensitive to changes. Traditionally, most change-proneness prediction has been studied based on source codes. However, change-proneness prediction in the early phase of software development can provide an easier way for developing a stable software by modifying the current design or choosing alternative designs before implementation. To address this need, we present a systematic method for calculating the behavioral dependency measure (BDM) which helps to predict change-proneness in UML 2.0 models. The proposed measure has been evaluated on a multi-version medium size open-source project namely JFreeChart. The obtained results show that the BDM is an useful indicator and can be complementary to existing OO metrics for change-proneness prediction.

It is difficult to adopt a simulation technology for simulating a software process because of the difficulty in developing a simulation model. In order to resolve the difficulty, we consider the following issues: reducing the cost to develop a simulation model, reducing the simulation model complexity, and increasing the modularity of a simulation model. We propose an approach to deriving a discrete event system specification (DEVS)-Hybrid simulation model from a software process engineering meta-model (SPEM)-based software process model. We provide the mapping between the elements of SPEM and the DEVS-Hybrid formalism and the transformation rules for automatically deriving a simulation model from a descriptive process model. Our approach resolves the issues by the transformation rules and the hierarchical and modularized modeling properties of UML and DEVS.

The needs of software maintenance and the importance of maintenance project management increase rapidly in the military avionics industry. Although few previous studies related to the maintenance effort estimation were proposed, they had two drawbacks:(1) the needs of some input parameters which are hard to measure precisely at early stage, (2) the passive support of "what-if" analysis by exploring the impact of changes among input parameters for more realistic estimation. In this paper, we suggest probabilistic effort estimation model for military avionics software maintenance by considering structural characteristics. We elicited the four aspects to the maintenance effort including structural characteristics, developed probabilistic maintenance effort estimation model based on Bayesian network with a data set of 76 military avionics software maintenance projects in the Republic Of Korea Air Force (ROKAF).

Many software organizations facing tough competitions struggle to develop quality software on time within budget and to satisfy business needs. As the users' needs become complicated with respect to the functional as well as non-functional requirements, developing quality software that satisfies such users' requirements in a timely manner is the main concern of the software organizations, which we believe is the goal of software engineering. For the last several decades, there have been many research and developments going on in order to meet the goal of software engineering. One of such attempts is software process improvement, which is based on the premise of that the quality of software is dependent on the quality of software process used in the development of software. For software process improvement, the current software process of the organization needs to be evaluated and then the improvement plan is established and executed to gradually reduce the gap between the current process and to-be process.

The quality of software measurement data affects the accuracy of project manager's decision making using estimation or prediction models and the understanding of real project status. During the software measurement implementation, the outlier which reduces the data quality is collected, however its detection is not easy. To cope with this problem, we propose an approach to outlier detection of software measurement data using the k-means clustering method in this work.

Systematic configuration management is important for successful software product lines. We can use aspect-oriented software development to decompose software product lines based on features that can ease configuration management. In this paper, we present a military maintenance product line that employs such strategy. In particular, we applied a specific approach, feature based modeling (FBM), in the construction of the system. We have extended FBM to address properties specific to product line. We will discuss the advantages of FBM when applied to product lines. Such gains include the functional decomposition of the system along user requirements (features) as aspects. Moreover, those features exhibit unidirectional dependency (i.e. among any two features, at most one depend on another) that enables developers to analyze the effect of any modification they may make on any feature. In addition, any variations can be captured as aspects which can also be incorporated easily into the core asset if such variation is deemed to be important enough to be included in the product line for further evolution.

Almost methods in embedded software modeling take software architecture as one of the crucial parts of the design process. Since a principal role of embedded software is the interaction with its environments, architectures that describe the dynamic aspects are also needed. Although such architectural view is significantly important in embedded software development, the existing approaches do not practically guide the architectural design based on the dynamic aspects. In this paper, we propose an operational architecture to represent the dynamic aspects of an embedded software. Also we explain how to use our operational architecture in the process of embedded software modeling. Our operational architecture effectively reflects interaction-based dynamic behavior of the system, and gives traceability between requirements and design model.

Many prior approaches in UML-based embedded software design incorporate state-based behavior modeling. However, interaction-based behavior modeling provides more intuitive view of a system. In this paper, we propose an approach to interaction-based behavior modeling of embedded software using UML 2.0. We use the interaction overview diagrams and the sequence diagrams to model the behavior. We present the method of constructing interaction-based behavior model with an example. We also briefly describe the idea of generating executable code from it.

Software composition for timely and affordable software development and evolution is one of the oldest pursuits of software engineering. In current software composition techniques, Component-Based Software Development (CBSD) and Aspect-Oriented Software Development (AOSD) have attracted academic and industrial attention. Black box composition used in CBSD provides simple and safe modularization for its strong information hiding, which is, however, the main obstacle for a black box composite to evolve later. This implies that an application developed through black box composition cannot take advantage of Aspect-Oriented Programming (AOP) used in AOSD. On the contrary, AOP enhances maintainability and comprehensibility by modularizing concerns crosscutting multiple components but lacks the support for the hierarchical and external composition of aspects themselves and compromises the important software engineering principles such as encapsulation, which is almost perfectly supported in black box composition. The role and role model have been recognized to have many similarities with CBSD and AOP but have significant differences with those composition techniques as well. Although each composition paradigm has its own advantages and disadvantages, there is no substantial support to realize the synergy of these composition paradigms; the black box composition, AOP, and role model. In this paper, a new composition technique based on representational abstraction of the relationship between component instances is introduced. The model supports the simple, elegant, and dynamic composition of components with its declarative form and provides the hooks through which an aspect can evolve and a parallel developed aspect can be merged at the instance level.

While the way we build software affects significantly its maintenance in terms of the effort and cost, the experience level of the maintainer in a software acquirers' organization is also one of concern. In this context, often the maintainer is the user of the system. Unfortunately, it is quite possible to lose the trustworthiness of the software due to the inexperience of the maintainer, especially when the maintainer is without the help of the original developers. One remedy for providing security against the effects of the maintainer's software modifications is to restrict the access to software parts (modules) relative to the experience level of the maintainers. For such a remedy to be successful, the software should be constructed in such a way that its parts under maintenance affect others as little as possible. We propose an approach to software construction aligning the dependencies among software parts in one direction so that they are allocated to maintainers based on their experience level. Our approach decomposes the software into parts based on functionality and orders the parts by essentiality, which indicates how difficult it is to change each part. Then, we align the dependencies in such a way that the less essential functionality is dependent on the more essential functionality. Consequently, any modification on less essential functionality does not affect the essential functionalities. To demonstrate the feasibility of our proposed approach, we applied it to a military application and found that the constructed software enables us to confine maintainers' activity within a limited working area, and thus the software is safer against maintainers' modification. Copyright © 2006 John Wiley & Sons, Ltd.

Functionalities in a software system can be categorized as accidental or essential, where accidental functionalities are dependent on essential ones, but not vice versa. Distinguishing essential functionalities from accidental ones in the development can lead to the reduction of maintenance effort and to the trustworthy system. In this paper, we propose feature based modelling (FBM) in which accidental functionalities are aligned with essential functionalities. The feature in this approach, as a logical unit, provides traceability from a functionality in the requirements to an implemented module with effective dependency management, thus the accidental features can be modified with minimal disruption to the essential features. FBM enables us to limit working boundary of maintenance activities, thus helps to keep the trustworthiness of the system against unskillful modification.

The existing cohesion metrics for classes do not consider the characteristics of dependent instance variables that are commonly used in a class and, thus, do not properly reflect the cohesiveness of the class. This paper presents an approach for improving the cohesion metrics by considering the characteristics of the dependent instance variables in an object-oriented program.

Abstract The authors insist that monotonicity is a necessary property of a good cohesion metric and the violation of the monotonicity property limits the application of CBMC. They also state that the augmented CBMC can also be used as a guideline for quality evaluation and restructuring of poorly designed classes. This paper raises the question about the necessity of monotonicity by analyzing the reason that causes CBMC to violate the monotonicity property. In addition, we give a detailed description of the restructuring procedure based on CBMC. Copyright © 2003 John Wiley & Sons, Ltd.

Software often needs to be modified to accommodate requirements changes during the software lifecycle. To deal with several accidental requirements changes related to software maintenance, a systematic and safe approach to modifying software is needed. Design patterns provide a high degree of design flexibility for such accidental requirements changes. In this paper, we propose an automated approach to refactoring based on design patterns in Java programs. In our approach, for a particular design pattern, we define an inference rule to automatically identify a set of candidate spots and a refactoring strategy to transform a candidate spot into the desired design pattern structure. A candidate spot may be a class or a set of classes to which design patterns can be applied. We believe that our approach would be helpful to maintainers in the sense that much manual analysis of source code can be reduced, and the method of automated program transformation preserves behavior of the original program by means of the refactoring technique.

Abstract Roles and role models have received much attention as useful concepts for developing highly reusable and dynamically evolvable systems. Role models belong to the category of collaboration‐based development techniques, but most of the existing approaches to role models do not explicitly incorporate the core principle of collaboration‐based developments as an essential property of their primary design goals. Consequently, the existing approaches still suffer from a problematic phenomenon that the structural and behavioral constraints defined in a role system can be violated during the role‐binding stage. We call such a problematic phenomenon the role‐binding anomaly. In order to alleviate the role‐binding anomaly, we propose an enhanced role model, in which all role instances and core objects can exist by themselves, namely, they can be developed, executed, and tested independently. Roles and core classes can be bound to each other at the instance level. In addition, the role system describes and encapsulates the behavior for dynamic reconfigurations among role instances. The enhanced role model is designed so as to be meaningful with respect to software engineering principles, rather than dynamic evolution. It also facilitates role model implementation using general programming languages (i.e. not supporting dynamic specialization) such as Java. To illustrate how the proposed role model makes such benefits, we develop a set of Java classes necessary for implementing the enhanced role model in the form of a Java package role, and present a simplified automatic teller machine system as an example application. Copyright © 2002 John Wiley & Sons, Ltd.

To ensure that a component-based software system can run properly and effectively, the qualities of constituent components have to be assured. Third-party certification is a safe approach that buyers should trust when dealing with component software. However, current third-party certification methods do not support proper functional testing, which is the most important factor when selecting the component. In this paper, we will suggest a framework of third party component testing of functionality, satisfying the following given constraint. evaluation of a large number of components within short period of time in a cost-effective way. In this framework, we identify, the metadata that a component developer should provide to the third party tester and define the process for third party testing using these metadata. To evaluate our framework, we conducted several experiment with Component Test Manager (CTM), prototype tool for EJB component testing. The result shows that our metadata are positively necessary and the participation of a component developer is the key to third party testing.

Process tailoring and verification are very important since project-specific processes are tailored from an organizational process standard and many quality assurance activities are based on the process standard. However, existing research does not provide a systematic method for process tailoring and verification. In this paper, we propose a systematic method for formalizing a process standard clearly with encapsulated reusable process modules for tailoring and verifying tailored process. AAG (activity artifact graph) is used to represent and tailor each process module. Additionally, a prototype tool is implemented to support the proposed method. We believe that the proposed method is helpful in tailoring a process standard and verifying a tailored process.

Scenario-based modeling is emerging as a key technology in software development because scenarios are easy to describe and understand, naturally describing the real world, and highly used in several development phases. Scenario-Based Software Modeling (SBSM) represents scenarios with a formal method, and then integrates each scenario into a global one excluding redundant, incomplete, and inconsistent elements. An issue which is not yet proposed a clear solution in SBSM is the handling of different abstraction levels. In the existing proposals, this problem is hidden with an implicit assumption that all such scenarios have the same abstraction levels, which we believe to be unrealistic. In our research, we propose a Hierarchical Object-Oriented Petri Net (HOONet) as a method to specify the scenarios, and also suggest a method to integrate scenarios including different abstraction levels as well as redundancy, incompleteness, and inconsistency. Coordinating abstraction levels of scenarios can be achieved by considering scenario models as state-based transition models and verifying the transition models with respect to behavioral equivalence. In order to show the effectiveness of our suggestion, overall processes of SBSM using HOONet are explained with a practical example.

Abstract Indicating that CBMC does not satisfy the monotonic property in terms of the number of interactions, Xu and Zhou proposed an augmented definition of CBMC by adopting cut set instead of glue methods. The augmented CBMC clearly satisfies the monotonic property. However, CBMC is designed to overcome the problem with respect to the number of interactions and, therefore, focuses on the interaction pattern, especially, member connectivity. Consequently, it does not make sense to mention the monotonic property of CBMC with respect to interaction number. Moreover, the notion of glue methods allows several interpretations on the design quality of a class. However, that meaningful interpretation is not possible for the augmented definition due to the removal of the notion of glue methods. Copyright © 2001 John Wiley & Sons, Ltd.

Component based development is an emerging discipline of software development. Recently, the growth of middleware technologies has brought the notion of server-side component into CBD for developing mission-critical applications. The authors propose a method for designing reliable component systems for mission-critical tasks. To this end, they formulate the MTS system (Microsoft Transaction Server) and develop a framework for describing the specification and design of component based systems and reasoning about them. For illustrating our framework, we show that the design of a simple bank example violates its specification. We strongly believe that the refactoring of transaction boundaries is common practice for improving scalability, and thus, the developed framework is useful when evaluating refactorings.

Petri net is used widely to analyze and model various systems formally. Recently, many Petri nets mania devote their efforts to enhancing and extending the expressive power of Petri nets. One such effort is to extend Petri nets with object-oriented concepts. An object-oriented paradigm provides excellent concepts to model real-world problems. Object-oriented concepts allow us to build software systems easily, intuitively, and naturally. Although several high-level Petri nets with the concept of objects are suggested, these nets do not fully support the object-oriented concepts. In this paper, we propose a hierarchical object-oriented Petri net (HOONet). The formal syntax and semantics of HOONet are explained in detail. HOONet supports a wide range of object-oriented features including abstract, encapsulated and modularized objects, object interaction by message passing, inheritance, and ploymorphism. HOONet also supports a variety of modeling and analysis mechanisms such as incremental modeling of evolving systems, unfolding the HOONet to lower level Petri net, and incremental reachability analysis for HOONet models. We demonstrate the usefulness of HOONet by applying it to modeling and analysis with an example.

In object-oriented systems, cohesion refers to the degree of the relatedness of the members in a class and strong cohesion has been recognized as a highly desirable property of classes. We note that the existing cohesion measures do not take into account some characteristics of classes, and thus often fail to properly reflect the cohesiveness of classes. To cope with such a problem, we propose a new cohesion measure where the characteristics of classes are incorporated. Our cohesion measure takes into account the members that actually have impact on the cohesiveness of a class, and is defined in terms of the degree of the connectivity among those members. We develop a cohesion measurement tool for C++ programs, and perform a case study on a well-known class library in order to demonstrate the effectiveness of our new measure. By performing principal component analysis, we also demonstrate that our measure captures a new aspect of class properties which is not captured by the existing cohesion measures. Copyright © 2000 John Wiley & Sons, Ltd.

This paper presents a method for the selection of test sequences from statecharts. It is shown that a statechart can be transformed into a flow graph modelling the flow of both control and data in the statechart. The transformation enables the application of conventional control and data flow analysis techniques to test sequence selection from statecharts. The resulting set of test sequences provides the capability of determining whether an implementation establishes the desired flow of control and data expressed in statecharts. Copyright © 2000 John Wiley & Sons, Ltd.

We propose an operational component specification method that provides execution models for analyzing behaviors as well as adopting checking rules for consistency. Our proposed operational component specification method will help the users to capture the meaning of components in a precise and abstract manner. Our method is mainly based on two ideas, object-orientation and the action system. Object-orientation makes specifications easy to understand and the action system leads to a simple and clear view of behaviors. Our method utilizes the Petri net formalism, especially the notion of tokens, in order to handle dynamic configuration in each component. We develop an extended version of Petri nets, called Object Petri Nets, to build execution models and extend analysis techniques of Petri nets.

Model checking is a formal verification technique which checks the consistency between a requirement specification and a behavior model of the system by exploring the state space of the model. We apply model checking to formal verification of concurrent object-oriented systems, using an existing model checker SPIN which has been successful in verifying parallel systems. First, we propose an Actor-based modeling language, called APromela, by extending a modeling language Promela which is a modeling language supported in SPIN. APromela supports not only all the primitives of Promela, but additional primitives needed to model concurrent object-oriented systems, such as class definition, object instantiation, message send, and synchronization. Second, we provide translation rules for mapping APromela's such modeling primitives to Promela's. By giving an example of specification, translation, and verification, we also demonstrate the applicability of our proposed approach, and discuss the limitations and further research issues.

Although object-oriented paradigm is becoming a more realistic approach to the development of large-scale software systems, the existing object-oriented notations and methodologies do not fully support the development of distributed object systems. In this paper, we integrate Meta-Object Protocol (MOP) into a de facto standard object-oriented modeling language UML together to build a software architecture for distributed object systems. We propose a high-level extension of conventional MOPs, called diMOP which helps to develop distributed object systems by realizing a reflective architecture. To incorporate diMOP with UML, we introduce two new specification languages: Class Diagram Supporting diMOP (CDSM) and Dynamically Configurable Object-oriented Statemachine (DCOS), which are proposed to replace the class diagram and the state diagram of UML. The two specification languages support the specification of dynamic configuration behaviors as well as incorporating the diMOP. This paper gives a methodology to develop efficiently distributed object systems through UML.

Modified programs are required to be retested to determine whether changes have been made correctly and to investigate whether those cause any adverse effect on the program behavior. Then, the key issue is the extent of the retesting tasks. To save time and efforts, retesting should be done on only the parts that might be affected by changes. Change impact analysis is the activity which identifies the parts to be retested. Object-oriented paradigm is based on several concepts such as encapsulation, inheritance, polymorphism, and dynamic binding. Although these features contribute to the reusability and extensibility of systems, they produce complex dependencies between classes and attributes, which make it difficult to identify the affected components by changes. We propose an approach for analyzing change impact in a class hierarchy. Our approach is based on the class firewall method, but aims to reduce the retesting effort significantly by taking a member function as a test unit. We deal with the impacts of changes associated with various object-oriented features as well as types of changes which can occur at the level of a data member a member function, a class, and an inheritance relation.

Software reengineering for object-oriented rearchitecturing offers an exciting opportunity in migrating old legacy systems to evolvable systems in a disciplined manner. In the twofold-strategy software reengineering for object-oriented rearchitecturing, one of the problems to be solved is to derive a proper object-oriented model from the output of reverse engineering and the output of forward engineering. In general, the outputs of forward and reverse engineering can be inconsistent in their abstract levels, the amount of design information, naming conventions, and structures. In this paper we present an Object-oriented model Refinement Technique (ORT) to build a final object model in the twofold-strategy software reengineering. We first organize the information gained from reverse engineering into specification information tree, and then compare the entities in the specification information tree with the information from forward engineering using tree-structured data dictionary to produce the final model. We demonstrate the usability of ORT by an example.

In process-driven software development environment, process management plays an important role during the process execution. In order to achieve effective management of software processes, managerial decision makings on development process need to be based on the analysis of the software processes regarding the development environment. In this paper we propose a new approach to process management through the formal process modeling and analysis techniques, called MAM nets based on Pr/T net formalism. For the effective modeling and analysis, MAM nets provide high-level modeling constructs for both process activities and human resources. MAM nets not only support the standard Petri-net analysis techniques but also provide additional analysis techniques as well as the process enactment mechanism for the effective management of software processes.

Robot workcell programming is an application where object oriented programming paradigms can be effectively applied to handle the issues such as concurrency and autonomy. We present an object model named Task.o, and Task object Coupling (ToC) programming technique which uses Task.o objects. This approach is designed to increase the level of reusability, expandability, modifiability, and productivity. We define the development steps of using the Task.o object model and the ToC technique and demonstrate each step.

Among the agents deployed on the Web, search agents which can query multiple search engines simultaneously are gaining popularity among end-users. As the number of users and search engines increase, however, establishing multiple connections to remote search engines has the potential to saturate the network and increase the load on the server running the search agent. To resolve these issues, we propose a client-oriented distribution architecture for Web search agents. Our architecture allows having multiply replicated agents distributed throughout the network initiate the queries while localizing the network traffic to the client's machine. Special attention has been made on the design and implementation of a search agent based on our proposed architecture that limits its use of network resources and prevents skewing the logs on the remote sites. We also present the evaluation results of our Web search agent.

An architecture-independent software development approach for parallel processing systems is presented. This approach is based on the parallel object oriented and functional computation model PROOF and separates the architecture dependent issues from software development. It also facilitates software development for any parallel processing systems by relieving the programmers from the consideration of processor topology and various parallelization aspects of the software. Our approach allows the exploitation of parallelism at both levels of granularity: object level and method level, thereby making our approach effective for software development for various MIMD computers. Software developed using our approach reflects the parallel structure of the problem space which makes the software more understandable and modifiable. A framework consisting of object-oriented analysis, object-design, coding and transformation phases is presented for software development for parallel processing systems. An example is given to illustrate this approach.

Developing software for distributed computing systems is challenging, due to lack of good software development methodologies for distributed computing systems. It is very important to develop reliable, adaptable and expandable application software for distributed computing systems. Autonomous decentralized systems (ADS) is a distributed computing system with online expandability, online maintainability and fault tolerance capability. A framework for developing ADS application software is presented. Our framework consists of object oriented requirements analysis, system design, implementation, allocation, verification and maintenance. It is based on the object oriented computation model developed for ADS application software development which supports online expandability and online modifiability. CASE environments for ADS software development are also discussed.>

Developing software for distributed computing systems is challenging due to lack of effective software development methodologies and tools. In particular, because many errors in the source code can be traced to the errors in the requirements specification, it is especially important to have effective verification techniques for the requirements specification. In this paper, an approach to verification of object-oriented requirements specification (OORS) in software development for distributed computing systems is presented. In our approach, the requirements specification generated by object-oriented analysis is described using a formal specification language, which is transformed into an information tree. Then, the completeness and consistency of the requirements specification expressed in terms of the information tree is verified by comparing it with the original requirements statement.>

A partitioning approach for object-oriented software development in parallel processing systems is presented. The objective of the partitioning approach is to improve the overall performance of a software system by minimizing communication cost among objects. The software system is modeled by a graph, and a bottom-up clustering technique is presented to partition the objects into a set of clusters to achieve this objective.>

An object-oriented approach to software development for parallel processing systems is presented. This approach is based on a computation model which incorporates the functional paradigm in the object-oriented paradigm and allows exploitation of massive parallelism without sacrificing the effectiveness of the object-oriented paradigm. The issues related to the development processes are discussed.>