Mingling of Program Slicing to Designing Phase

Regression testing is for retesting modified software to ensure that changes are correct and do not adversely affect other parts of the software. It is usually One extremely hard for engineers to figure out how a change in software will echo in other parts of the software. We propose a framework that combines machine learning and program slicing for test cases prioritization to solve the problem. We developed a library, called Intelligent Test Oracle Library (InTOL), for the instrumentation of a system under test (SUT) to generate test traces. The program slices serve to indicate the relevance of test cases to regression testing of software modifications. Then we relate the slicing information with the test traces. We use Artificial Neural Network (ANN) as our underlying technology for machine learning. In the training phase, we first use ANN to learn the count of times that a program segment will be visited in the execution of a test case. We then use the count estimation for the program segments as a part of our feature vector for a test input and feed the vector to another ANN for test prioritization of the test input. We experiment with two benchmark programs of Software-artifact Infrastructure Repository. Our experiment data shows a good fault-detection ability.

Prioritized static slicing and its application to fault localization

Fault finding is an activity to locate the fault or bug present in a software. It is a very time taking job and needs much more effort if done manually. Hence, automated fault localisation is always in high demand which reduces the human effort and also makes the task more accurate. Among different existing debugging techniques, spectrum-based debugging is the most efficient for automated fault localisation. Dynamic program slicing is another technique which can reduce the debugging time by reducing the unaffected source codes depending on slicing criteria. In this paper, we present a spectrum-based fault localisation technique by using dynamic slicing. Context-sensitive slicing is used to diminish fault localisation time and makes the process more effective. SBFL metrics are used in the sliced program to find the suspiciousness score of individual program statements. The efficiency of the proposed approach is evaluated on three open-source programs. From results, we notice that due to dynamic slicing the technique takes less time to find the suspiciousness score of individual statements in the sliced program compared to original program. We have also observed that the programmer needs to inspect less source code to detect the buggy statement. The result says that the proposed approach outperforms the pure spectrum-based fault localisation techniques.

Observation Based Slicing is a program slicing technique that depends purely on the observation of dynamic program behaviours. It iteratively applies a deletion operator to the source code, and accepts the deletion (i.e. slices the program) if the program is observed to behave in the same was as the original with respect to the slicing criterion. While the original observation based slicing only used a single deletion operator based on deletion window, the catalogue of applicable deletion operators grew recently with the addition of deletion operators based on lexical similarity. We apply a hyperheuristic approach to the problem of selecting the best deletion operator to each program line. Empirical evaluation using four slicing criteria from Guava shows that the Hyperheuristic Observation Based Slicing (HOBBES) can significantly improve the effeciency of observation based slicing.

Traditional program slicing techniques are crucial for early bug detection and manual/automated debugging of online code snippets. Nevertheless, their inability to handle incomplete code hinders their real-world applicability in such scenarios. To overcome these challenges, we present NS-Slicer, a novel learning-based approach that predicts static program slices for both complete and partial code Our tool leverages a pre-trained language model to exploit its understanding of fine-grained variable-statement dependencies within source code. With this knowledge, given a variable at a specific location and a statement in a code snippet, NS-Slicer determines whether the statement belongs to the backward slice or forward slice, respectively. We conducted a series of experiments to evaluate NS-Slicer's performance. On complete code, it predicts the backward and forward slices with an F1-score of 97.41% and 95.82%, respectively, while achieving an overall F1-score of 96.77%. Notably, in 85.20% of the cases, the static program slices predicted by NS-Slicer exactly match entire slices from the oracle. For partial programs, it achieved an F1-score of 96.77%–97.49% for backward slicing, 92.14%–95.40% for forward slicing, and an overall F1-score of 94.66%–96.62%. Furthermore, we demonstrate NS-Slicer's utility in vulnerability detection (VD), integrating its predicted slices into an automated VD tool. In this setup, the tool detected vulnerabilities in Java code with a high F1-score of 73.38%. We also include the analyses studying NS-Slicer’s promising performance and limitations, providing insights into its understanding of intrinsic code properties such as variable aliasing, leading to better slicing.

Many recent studies on fault localization based on program slicing have mainly focused on static slicing techniques, while the research on fault localization using dynamic slicing tool is insufficient. One reason is that dynamic slicing tools are less available than static ones. In our paper, we present the use of the dynamic slicing tool, JSlice, which is a dynamic slicing tool available for Java programs. Our experiments choose six representative Java programs, all of which were Java version of Siemens programs which were translated from C version. The results show that dynamic slicing can effectively locate faults and JSlice is an effective dynamic slicing tool.

Observation-based slicing is a recently-introduced, language-independent slicing technique based on the dependencies observable from program behaviour. Due to the well-known limits of dynamic analysis, we may only compute an under-approximation of the true observation-based slice. However, because the observation-based slice captures all possible dependence that can be observed, even such approximations can yield insight into the limitations of static slicing. For example, a static slice, S, that is strictly smaller than the corresponding observation based slice is potentially unsafe. We present the results of three sets of experiments on 12 different programs, including benchmarks and larger programs, which investigate the relationship between static and observation-based slicing. We show that, in extreme cases, observation-based slices can find the true minimal static slice, where static techniques cannot. For more typical cases, our results illustrate the potential for observation-based slicing to highlight limitations in static slicers. Finally, we report on the sensitivity of observation-based slicing to test quality.

A System of Systems (SoS), composed of independent constituent systems, can create synergy among its systems to achieve a common goal. Many studies have used statistical model checking techniques to verify how well an SoS can achieve its goals. SoS models are usually complex and probabilistic, which makes statistical verification computationally expensive. To reduce this cost, dynamic slicing techniques can be applied to SoS models since both dynamic slicing and statistical verification focus on the models' execution samples. However, existing dynamic slicing techniques cannot guarantee executable accurate slices of SoS models when the models contain uncertainty. Therefore, we propose a hybrid slicing approach that combines dynamic backward slicing and modified observation-based slicing to produce accurate executable slices. Experimentation on the proposed technique found that the verification time was significantly reduced (47--56%), depending on the property, while preserving the verification results.

The energy consumption optimization of embedded systems can be undertaken in multiple levels of hardware and software. In this paper, based on the energy consumption measurement of embedded software, the generating reasons and influencing factors of embedded software energy consumption on the micro-structure and circuit level of hardware were analyzed firstly. Then, to reduce the energy consumption of embedded software, some measures were adopted to improve the software-related characteristics on the source code and algorithm level. Finally, a C program of typical "Eight Queens" puzzle was optimized with three methods of source code level, algorithm level and a mix of source code and algorithm level, the highest energy savings of embedded systems could achieve up to 93.1%, and experimental results demonstrated that the energy consumption optimization methods of embedded software were feasible and effective to minimize the energy consumption of embedded systems.

Dynamic slicing algorithms have been considered to aid in debugging for many years. However, as far as we know, no detailed studies on evaluating the benefits of using dynamic slicing for detecting faulty statements in programs have been carried out. We have developed a dynamic slicing framework that uses dynamic instrumentation to efficiently collect dynamic slices and reduced ordered Binary Decision Diagrams (roBDDs) to compactly store them. We have used the above framework to implement three variants of dynamic slicing algorithms including: data slicing, full slicing, and relevant slicing algorithms. We have carried out detailed experiments to evaluate these algorithms. Our results show that full slices and relevant slices can considerably reduce the subset of program statements that need to be examined to locate faulty statements. We expect that the observations presented here will enable development of new slicing based algorithms for automated debugging.

Vulnerability detection through cross-modal feature enhancement and fusion

A formal executable semantics of a programming language has the necessary information to develop program debugging and reasoning techniques. In this paper we choose such a particular technique called program slicing and we introduce a generic algorithm which extracts a set of side-effects inducing constructs, directly from the formal executable semantics of a programming language. These constructs are further used to infer program slices, for given programs and specified slicing criteria. Our proposed approach improves on the parametrization of the language tools development because changes in the formal semantics are automatically carried out in the slicing procedure. We use the rewriting logic and the Maude system to implement a prototype and to test our technique.

Program Slicing minimizes the program to substatements, which produces the same behaviour where the subset of the program also called the program slice comprises of the chunks or statements of the program which impact the values calculated at a point of absorption called as the slicing criterion. The concept of slicing was introduced by Weiser using a data-flow diagram [1]. If you look at static slicing, it does not make any suppositions about the input of a particular program, whereas the dynamic slicing counts on a distinct test case. Object-oriented programming is an extensively used software development technique. In this paper, we will create an approach to compute a static slice as well as a dynamic slice of a set of programs by creating an intermediary representation of the program, i.e. a Java program dependence graph and Java system dependence graph (JSysDG) (in case of multiple functions) and then use it as input and apply the slicing algorithm in order to compute slice of the program with respect to the slicing criterion and analyze the results as well.

Periodic refactoring of a large source code often becomes a ne- cessity especially for long-lived projects. In order to increase maintainabil- ity and extensibility of such projects, design pattern based refactoring can be seen as an emerging alternative. Manual inspection of source code to find candidate spots where patterns can be introduced is time consuming. Therefore automated tools can help in identifying candidate spots where patterns can be introduced. The level of source code abstraction plays an important role for building such tools. We propose a new abstrac- tion for object oriented source code that is named as Refactoring Pattern (ReP) Graph to realize an eective design pattern based refactoring tool. The ReP graph abstracts the source code information thereby making the process of design pattern inference easier. The proposed tool identifies candidate spots in a given source code to introduce design patterns.

A dynamic slicing algorithm is proposed in this paper along with its implementation which is dynamic for concurrent Component-oriented programs carrying multiple threads. As a part of representing the concurrent COP (CCOP) effectively, an intermediate graph is developed called Concurrent Component Dependency Graph (CCmDG). The system dependence graph (SDG) for individual components and interfaces are integrated to represent the above intermediate graph. It also consists of some new dependence edges which have been triggered for connecting the individual dependence graph of each component with the interface. Based on the graph created for the CCOP, a dynamic slicing algorithm is proposed, which sets the resultant by making the executed nodes marked during run time in Concurrent Components Dynamic Slicing (CCmDS) appropriately. For checking the competence of our algorithm, five case studies have been considered and also compared with an existing technique. From the study, we found that our algorithm results in smaller and precise size slice compared to the existing algorithm in less time.