Path exploration based on symbolic output

Efficient program path exploration is important for many software engineering activities such as testing, debugging and verification. However, enumerating all paths of a program is prohibitively expensive. In this paper, we develop a partitioning of program paths based on the program output. Two program paths are placed in the same partition if they derive the output similarly, that is, the symbolic expression connecting the output with the inputs is the same in both paths. Our grouping of paths is gradually created by a smart path exploration. Our experiments show the benefits of the proposed pathexploration in test-suite construction.Our path partitioning produces a semantic signature of a program --- describing all the different symbolic expressions that the output can assume along different program paths. To reason about changes between program versions, we can therefore analyze their semantic signatures. In particular, we demonstrate the applications of our path partitioning in debugging of software regressions.

SWAT is a novel dynamic symbolic execution engine for Java applications utilizing dynamic instrumentation. SWAT’s unique modular design facilitates flexible communication between its symbolic explorer and executor using HTTP endpoints, thus enhancing adaptability to diverse application scenarios. The symbolic executor’s ability to attach to Java applications enables efficient constraint generation and path exploration. SWAT employs JavaSMT for constraint generation and ASM for bytecode instrumentation, ensuring robust performance. SWAT’s efficacy is evaluated in the Java Track of SV-COMP 2024, achieving fourth place.

This paper presents the first concolic testing framework explicitly designed for quantum programs. The framework introduces quantum constraint generation methods for quantum control statements that quantify quantum states and offers a symbolization method for quantum variables. Based on this framework, we generate path constraints for each concrete execution path of a quantum program. These constraints guide the exploration of new paths, with a quantum constraint solver determining outcomes to create novel input samples, thereby enhancing branch coverage. Our framework has been implemented in Python and integrated with Qiskit for practical evaluation. Experimental results show that our concolic testing framework improves branch coverage, generates high-quality quantum input samples, and detects bugs, demonstrating its effectiveness and efficiency in quantum programming and bug detection. Regarding branch coverage, our framework achieves more than 74.27% on quantum programs with under 5 qubits.

It is well known that it is difficult to explore underwater terrains using an autonomous underwater vehicle due to the varieties and complexities of underwater terrain elements. Since conventional underwater terrain coverage techniques are usually based on the assumption that the underwater surface is planar, they generate an unnecessary exploration path especially on steep sloped surfaces of ocean basins. This paper proposes a new type of coverage technique, the hybrid terrain coverage framework (HTCF), which considers various surface conditions in three-dimensional environments and generates an efficient exploration path for all environments. The HTCF incorporates a planar terrain coverage algorithm, a spiral path terrain coverage algorithm, and a hybrid decision module to recognize and select the most suitable technique depending on the sloped surface variations. Simulation results show that the proposed HTCF is more efficient than the conventional terrain coverage algorithm in terms of the energy consumption of the underwater vehicle.

We describe a heuristic analysis technique for finding costly paths in programs, where the cost refers to the execution time or memory consumed by the program. The analysis can support various software engineering tasks, such as finding vulnerabilities related to denial-of-service attacks, guiding compiler optimizations or finding performance bottlenecks in software. The analysis performs sampling over symbolic program paths, which are computed with a symbolic execution over the program, and uses Monte Carlo Tree Search (MCTS) to guide the search for costly paths. We implemented the proposed method in Symbolic PathFinder and we evaluated it on Java programs. Our experiments show the promise of the technique for finding performance bottlenecks in software.

Path planning is crucial for the safe and efficient operation of autonomous systems like UAVs, where collision detection constitutes a major computational bottleneck. While sampling-based planning methods can explore complex spaces, they often suffer from slow convergence and suboptimal path quality. Although machine learning-based approaches have strong generalization capabilities, they rely on a large amount of training data and have poor interpretability. To address these issues, this study proposes a novel mechanism based on a Heterogeneous Graph Neural Network, aimed at solving the core computational bottleneck of collision detection in path planning. Our method leverages heterogeneous graphs as data representation to effectively capture the complex interactions between obstacles and free space in planning environments. The proposed mechanism comprises two collaborative modules: a path explorer and a path smoother. The explorer identifies a candidate path, which is subsequently refined and optimized by the smoother to produce a more efficient and higher-quality path. Experimental results in simulation environments demonstrate that by embedding spatial topological and semantic prior knowledge into the heterogeneous graph structure, our method can shorten path planning time. Thus, we proposes a new approach that leverages heterogeneous graph modeling to enhance path planning efficiency.

Good software engineering methodology can be rendered ineffective by the presence of deadline pressure. A simple model is developed to explain the possible responses to deadline pressure and to show that there is a tendency to divert resources away from software engineering activities under such conditions. Management is identified as being responsible for ensuring that software engineering activities are given adequate resources. A managerial strategy for achieving these ends is suggested.

Welcome to the first edition of the International Workshop on Test Oracles (TORACLE 2021) to be held virtually on August 24, 2021, co-located with the ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2021). Testing is an important activity in software engineering, especially with the growing adoption of software systems in safety-critical domains. Testing research, however, is mostly focused on determining which test inputs to use (e.g., proposing and evaluating test coverage criteria or automatic test generation tools). Regardless of the used coverage criterion, we need to know whether a given program executes correctly on a given input. Indeed, a test execution for which we cannot discriminate between success or failure is fruitless. This corresponds to the so-called ”oracle problem”, the problem of knowing whether a program behaves correctly for a specific input. While the importance of the oracle problem is well understood, only a few alternatives exist to manually deriving test oracles. This makes test oracle automation one of the main bottlenecks for full test automation. Therefore, novel approaches and tools are needed to address this important problem.

Source code review is a core activity in software engineering where a reviewer examines the code with the intention of finding bugs in the program. A lot of research has been carried out in understanding how software engineers perform code comprehension; however contribution of eye tracking traits seems to have not been addressed. This paper outlines a study conducted in an industrial environment of software engineers. It focused on understanding the visual attention of subjects with programming skills and subjects without programming skills and recognize the eye tracking traits required for source code review. The results indicate a significant difference in gaze behaviors of these groups. The key aspects of subjects with programming skills while source code review are required to have certain eye tracking traits like better code coverage, attention span on error lines and comments.

Enterprise information systems(EIS) focus on dealing with the complex business logic of collecting, filtering, processing, and distributing data for improving productivity and service in our daily life. The successful development of enterprise information system is the labor-intensive activities in software engineering, it requires the sophisticated human efforts for requirements validation, system design, implementation and verification. Our previous work RM2PT can help to achieve a validated requirements model through automatically generating prototypes from requirements models to support incremental and rapid requirements validation. In this paper, we present a tool named RM2EIS to further alleviate the problem of system development by supporting automatically generate the back-end source code of enterprise information system from the validated requirements model, which are achieved by several round requirements validation in RM2PT. We demonstrate that RM2EIS can achieve higher quality code (+8.27%) with less time cost (-61.92%) than the manual development through 9 case studies. Overall, the results were satisfactory. The proposed approach can be further extended and applied for the EIS development in the software industry. The tool can be downloaded at https://rm2pt.com/advs/rm2eis and a demo video casting its features is available at https://www.youtube.com/watch?v=5Nde-JYezg4.

Defect reports are generated from various testing and development activities in software engineering. Sometimes two reports are submitted that describe the same problem, leading to duplicate reports. These reports are mostly written in structured natural language, and as such, it is hard to compare two reports for similarity with formal methods. In order to identify duplicates, we investigate using natural language processing (NLP) techniques to support the identification. A prototype tool is developed and evaluated in a case study analyzing defect reports at Sony Ericsson mobile communications. The evaluation shows that about 2/3 of the duplicates can possibly be found using the NLP techniques. Different variants of the techniques provide only minor result differences, indicating a robust technology. User testing shows that the overall attitude towards the technique is positive and that it has a growth potential.

Verification and validation are becoming the most important activities in software engineering because of the stronger need to ensure and enhance quality. The system designers need to ensure the conformance of models with the functionalities of a target system and the correctness, safeness and reliability of its operating cycles. Many formal methods have been promoted to support such tasks and Petri nets formalism seems to be one of the most relevant one to evaluate control properties. But it lacks of structuration facilities to allow to handle large scale systems. The aim of this paper is to show that, for some guidelines, Petri nets can be integrated in usual object-oriented software methodologies in order to evaluate such properties. Hence, one can profit from contributions of both object and nets to handle quality in systems in a more satisfactory way.KeywordsObject MethodologyPetri NetsControl PropertiesVerification & Validation

Software development effort estimation is one of the most crucial activities in software engineering. Effort estimation permits managers and software engineers to anticipate, forecast, and precisely quote the schedule, budget and manpower requirements. By accurately estimating the effort; software projects can be saved from under run or over run. In this paper we have summarized and then analyzed the past work of software effort estimation in a systematic way. 10 researches were surveyed and explained briefly that how they are contributing towards solving the effort estimation problem in terms of time, cost or test. It also emphasizes that various effort estimation models have different pros and cons and can be used in different context on basis of different types of historical data. The survey discovered the most popular models used for effort prediction are supervised learning algorithms. The trends identified through this survey can help in exploring the potential research areas.

The study of change impact is a fundamental activity in software engineering because it can be used to plan changes, set them up and to predict or detect their effects on the system and try to reduce them. Various methods have been presented in the literature for this sector of maintenance. The objective of this project is to improve the maintenance of Object Oriented (OO) systems and to intervene more specifically in the task of analyzing and predicting the change impact. Among several models of representation, Bayesian Networks (BNs) constitute a particular quantitative approach that can integrate uncertainty in reasoning and offering explanations close to reality. Furthermore, with the BNs, it is also possible to use expert judgments to anticipate the predictions, about the change impact in our case. In this paper, we propose a probabilistic approach to determine the change impact in OO systems. This prediction is given in a form of probability.

Search-based software engineering (SBSE) consists of the application of metaheuristic search techniques—such as genetic algorithms, simulated annealing, hill climbing, and tabu search—to software engineering problems. This idea is based on the observation that some software engineering activities can be thought of as optimization problems, and on the fact that techniques providing exact solutions are, very often, unable to adequately scale to large, real-world software engineering problems. Define fitness functions to guide an automated search for solutions, rather than attempting to construct solutions from scratch by hand. SBSE moves the engineer up the abstraction chain, from the tedious and expensive role of detailed solution construction, to the potentially more productive and more cost-effective area of fitness function design. This approach has been repeatedly demonstrated to have successful applications across the software engineering life cycle from requirements and project planning to maintenance and testing. This special issue focuses on applications of search SBSE to the maintenance phase of the life cycle. After software testing 2, software maintenance is the most widely studied application area for SBSE research. Work on SBSE applications to problems in software maintenance can be traced back to the pioneering work of the Mancoridis et al. 3, which led to the development of the Bunch tool for software re-modularization 4. In the past five years there has been a significant increase in SBSE applications to software maintenance and evolution. Search-based techniques have been applied to post-development code improvement problems, such as object-oriented refactoring 5, 6, and imperative language slicing and transformation 7. Other applications are related to software engineering economics and project management problems, such as release planning 8-12, effort, and cost estimation 13-16, and project staffing and planning 17-20. Last, but not the least, SBSE has been applied to deal with service-oriented architectures, for example for services QoS-aware composition 21, service-level agreement negotiation 22, and testing 23. A complete overview of SBSE with a discussion of future research trends can be found in the recent International Conference on Software Engineering (ICSE) ‘Future of Software Engineering’ paper 24. This issue of the Journal of Software Maintenance and Evolution: Research and Practice features three outstanding papers, dealing with different aspects of software maintenance and evolution: release planning and staffing, re-factoring, and component substitution. The paper ‘Optimized Staffing for Product Releases—Focused Search and its Application at Chartwell Technologies’ by Puneet Kapur, An Ngo-The, Günther Ruhe, and Andrew Smith presents an approach for optimizing the staffing for product releases. The problem they solve can be viewed as part of the more general release planning problem, which assigns features to releases such that technical, resource, risk, and budget constraints are met. In particular, the genetic search-based approach the authors propose aims at assigning human resources to software development tasks, taking them from a pool of developers having different levels of skills. The applicability of the proposed approach is demonstrated with an industrial case study. The paper ‘Search-Based Refactoring: an Empirical Study’ by Mark O'Keffe and Mel Ó Cinnéide presents an approach to automatically re-factor, using search-based techniques, object-oriented systems that undergo repeated addition of functionality. Such addition can, very often, deteriorate the quality of the system's underlying design. Their re-factoring is guided by the QMOOD quality model 25, and the paper compares different optimization techniques, such as Genetic Algorithms, Simulated Annealing, and Multiple Ascent Hill-Climbing. The results of experiments carried out on five software systems suggest that the latter technique outperforms the others. The paper ‘Search-based Many-to-one Component Substitution’ by Nicolas Desnos, Marianne Huchard, Guy Tremblay, Christelle Urtado, and Sylvain Vauttier presents a search-based approach that allows the replacement of an obsolete component with a composition of multiple components. When a component becomes obsolete, the approach searches for a minimal assembly of other components, exposing their functionality by means of ports that preserves the behavior of the original component. The proposed approach has been evaluated on a set of randomly generated components. We hope that readers will enjoy this special issue and find the selected papers insightful and inspiring. We would like to thank all the authors who presented papers for this special issue: there were many good quality papers, but unfortunately we could accept only three of them. Last, but not the least, we would like to thank the reviewers who provided timely, detailed and constructive feedbacks to the authors. Without their precious help this special issue would not have been possible.