Static Slicing Techniques Research Articles

Weight prioritized slicing based on constraint logic programming for fault localization.

Fault localization, a technique to fix and ensure the dependability of software, is rapidly becoming infeasible due to the increasing scale and complexity of multilingual programs. Compared to other fault localization techniques, slicing can directly narrow the range of the code which needed checking by abstracting a program into a reduced one by deleting irrelevant parts. Only minority slicing methods take into account the fact that the probability of different statements leading to failure is different. Moreover, no existing prioritized slicing techniques can work on multilingual programs. In this paper, we propose a new technique called weight prioritized slicing(WP-Slicing), an improved static slicing technique based on constraint logic programming, to help the programmer locate the fault quickly and precisely. WP-Slicing first converts the original program into logic facts. Then it extracts dependences from the facts, computes the static backward slice and calculates the statements’ weight. Finally, WP-Slicing provides the slice in a suggested check sequence by weighted-sorting. By comparing it’s slice time and locate effort with three pre-exsiting slicing techniques on five real world C projects, we prove that WP-Slicing can locate fault within less time and effort, which means WP-Slicing is more effectively.

A proposed forward clause slicing application

The Clause slicing technique is static slicing techniques which also have forward and backward slicing methods. The Clause slice criteria are the clause and the clause number. In this paper, we have discussed the Clauser tool the forward clause slicing tool introduce some improvements to it. The Clauser mechanism divides the program code statement into clauses, depending on clause slicing rules, identifies the variables and built-in functions, then slices the clauses regarding the slice criterion that was entered by the user. Comparing to other static slicing techniques the clause slicing is more accurate and precise because it considers all the code in micro-level, where it focuses on every syntax in the code. The Clauser still needs to be enhanced to slice more code features.

Static slicing of Use Case Maps requirements models

Requirements specification is a crucial stage in many software development life cycles. As requirements specifications evolve, they often become more complex. The development of methods to assist the comprehension and maintenance of requirements specifications has gained much attention in the past 20 years. However, there is much room for improvement for model-based specifications. The Use Case Maps (UCM) language, part of the ITU-T Z.151 User Requirements Notation standard, is a visual modeling notation that aims to describe requirements at a high level of abstraction. A UCM specification is used to integrate and capture both functional aspects (based on causal scenarios representing behavior) and architectural aspects (actors and system components responsible for scenario activities). As UCM models evolve and grow, they rapidly become hard to understand and to maintain. In this paper, we propose a static slicing technique to enhance the comprehension of UCM models. The developed slicing approach is implemented within the jUCMNav tool. We validate the proposed approach using a mock system and three publicly available UCM specifications. The results suggest that, on average, the models can be reduced by about 70% through slicing without losing information required for comprehension and maintenance activities. A small experiment involving 9 participants also suggests that the understandability of UCM specifications and comprehension speed have both improved substantially by using jUCMNav’s new slicing feature.

Clauser: Clause Slicing Tool for C Programs

The Clause slicing technique is a static slicing technique. The clause slice criterion is the clause, which is the smallest part of the code line, with the clause number. In this paper, we introduce the “Clauser,” which is a new clause slicing tool for C programs. The Clauser is a slicing tool that divides the program code lines into clauses, depending on certain rules, and then it slices the clauses by applying the rules of clause slicing and returns the slices of the slice criterion. Compared to other static slicing techniques, clause slicing is more accurate because it considers all code phrases that may affect the program flow. Implementation results showed that the Clauser succeeded in automating a part of clause slicing.

A selection of distinguished papers from the 19th Working Conference on Reverse Engineering 2012

ABSTRACTThis special issue contains a selection of distinguished papers from the 19th Working Conference on Reverse Engineering, held in Kingston, Ontario, Canada on October 15th–18th, 2012. The papers address a variety of topics related to reverse engineering, namely the analysis of execution traces, development of fast and efficient forward static slicing techniques, and mining of software repositories aiming at deriving novel patterns related to reverse engineering activities, such as the migration in Java libraries and the analysis of effects of file editing patterns on source code quality. Copyright © 2014 John Wiley & Sons, Ltd.

Static Slicing Technique with Algorithmic Approach

In order to improve the accuracy of the static programslicing which is used to locate the faults that cause an exception,we propose a new algorithm which isstored when an exception occurred. The proposed approachconsists of various steps and figure out those methods and statements thathave not been executed. Then, these methods which are notexecuted will be ignored when building the system dependencegraph. Finally, the accurate slice will be got by adopting theimproved program slicing algorithm. And the result shows that using our approachthe slice is 8 percent less than using the general static programslicing algorithm on average.One approach to improve the comprehension ofprograms is to reduce the amount of data to be observedand inspected. Programmers tend to focus andcomprehended selected functions (outputs) and those partsof a program that are directly related to that particularfunction rather than all possible program functions. Oneapproach is to utilize program slicing, a program decomposition technique that transforms a large programinto a smaller one that contains only statements relevantto the computation of a selected function.

Actor-based slicing techniques for efficient reduction of Rebeca models

Slicing is a program analysis technique which can be used for reducing the size of the model and avoid state space explosion in model checking. In this work a static slicing technique is proposed for reducing Rebeca models with respect to a property. For applying the actor-based slicing techniques, the Rebeca control flow graph (RCFG) and the Rebeca dependence graph (RDG) are introduced. We propose two different approaches for constructing the RDG, where each approach can be more effective under certain conditions. As the static slicing usually produces large slices, two other slicing-based reduction techniques, step-wise slicing and bounded slicing, are proposed as simple novel ideas. Step-wise slicing first generates slices that overapproximate the behavior of the original model and then refines it, and bounded slicing is based on the semantics of nondeterministic assignments in Rebeca. We also propose a static slicing algorithm for deadlock detection (in absence of any particular property). The efficiency of these techniques is checked by applying them to several case studies which are included in this paper. Similar techniques can be applied on the other actor-based languages.

Slicing-based Reductions for Rebeca

Slicing is a program analysis technique which can be used for reducing the size of the model and avoid state explosion in model checking. In this work a static slicing technique is proposed for reducing Rebeca models with respect to a property. For applying the slicing techniques, the Rebeca dependence graph (RDG) is introduced. As the static slicing usually produces large slices, two other slicing-based reduction techniques, step-wise slicing and bounded slicing, are proposed as simple novel ideas. Step-wise slicing first generates slices overapproximating the behavior of the original model and then refines it, and bounded slicing is based on the semantics of non-deterministic assignments in Rebeca. We also propose a static slicing algorithm for deadlock detection (in absence of any particular property). The applicability of these techniques is checked by applying them to several case studies which are included in this paper. Similar techniques can be applied on the other actor-based languages.