Dynamic slicing of distributed object-oriented programs

Barpanda, Soubhagya Sankar; Mohapatra, Durga Prasad

doi:10.1049/iet-sen.2010.0141

Cited by 22 publications

(21 citation statements)

References 23 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The input that the slicing algorithm takes is usually an intermediate representation of the program under consideration [28,29,45]. The first step in slicing a program involves specifying a point of interest which is called the slicing criterion and is expressed as a tuple (s, v), where s is the statement number and v is the variable that is being used or defined at s. Some of the recent techniques and applications of program slicing can be found in [8,11,37,40]. Instead of analyzing the data flow and control flow for the program as a whole, it is better to use the hierarchical structure of the object-oriented programs, especially Java programs to detect the impact of the change [15,38].…”

Section: Hierarchical Slicementioning

confidence: 99%

ACCo: a novel approach to measure cohesion using hierarchical slicing of Java programs

Panda

Mohapatra

2015

Innovations Syst Softw Eng

View full text Add to dashboard Cite

Maintainability of program parts refers to the ease with which these parts can be modified. Many existing metrics of internal quality attributes such as cohesion, coupling, etc. have been used in this regard. Cohesiveness among program parts is considered as a strong measure for the maintainability of object-oriented components and to predict the probability of being erroneous. Our objective is to propose a novel graph-based cohesion metric to measure the maintainability of different program parts in an object-oriented program and predict their fault proneness. We compute the cohesion of the sliced component as a measure to predict its correctness and preciseness. In addition, we wish to theoretically validate the proposed technique against the existing guidelines of cohesion measurement and compare it with some existing techniques. We propose a new cohesion metric named affected component cohesion (ACCo) to measure the maintainability of different program parts and predict their fault proneness. This metric is based on the hierarchical decomposition slice of an object-oriented program that comprises all the affected program parts. The slices are obtained with respect to some modification made to the program under consideration. It is essential to consider all possible dependence relationships along with the control and data dependences that exist between different program parts of an object-oriented program for a better program comprehension. To represent these dependences, we construct a suitable intermediate graph for an object-oriented program. Then, we compute the slice of the object-oriented program using the intermediate graph to extract the affected B S. Panda program parts. These extracted affected program parts are represented as nodes in the proposed affected slice graph. The critical and sub-critical nodes that require thorough testing are determined by estimating their cohesion measure. The theoretical validation signifies that ACCo satisfies all the existing properties for cohesion measurement. The results obtained are more precise and comparable with other existing approaches. ACCo is a more precise and practical technique to measure the inter-relatedness of affected program parts in an object-oriented program. The discussion on possible threats to its validity demonstrates the scope for improvement of this approach.

show abstract

Section: Hierarchical Slicementioning

confidence: 99%

ACCo: a novel approach to measure cohesion using hierarchical slicing of Java programs

Panda

Mohapatra

2015

Innovations Syst Softw Eng

View full text Add to dashboard Cite

show abstract

“…Dynamic code analyses for distributed systems also have been explored early on [18,31,34] and more in recent years [7,44,52], largely focusing on detailed analysis of program dependencies. However, the majority of these approaches were designed only for procedural programs [7]. For distributed object-oriented programs, backward dynamic slicing algorithms have been developed, yet it is still unclear whether they can work with (and scale to) real-world systems [7,44].…”

Section: Introductionmentioning

confidence: 99%

“…However, the majority of these approaches were designed only for procedural programs [7]. For distributed object-oriented programs, backward dynamic slicing algorithms have been developed, yet it is still unclear whether they can work with (and scale to) real-world systems [7,44]. And for impact analysis, forward slicing would be needed.…”

Section: Introductionmentioning

confidence: 99%

DistIA: a cost-effective dynamic impact analysis for distributed programs

Cai

Thain

2016

Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering

View full text Add to dashboard Cite

Dynamic impact analysis is a fundamental technique for understanding the impact of specific program entities, or changes to them, on the rest of the program for concrete executions. However, existing techniques are either inapplicable or of very limited utility for distributed programs running in multiple concurrent processes. This paper presents DISTIA, a dynamic analysis of distributed systems that predicts impacts propagated both within and across process boundaries by partially ordering distributed method-execution events, inferring causality from the ordered events, and exploiting message-passing semantics. We applied DISTIA to large distributed systems of various architectures and sizes, for which it on average finishes the entire analysis within one minute and safely reduces impact-set sizes by over 43% relative to existing options with run-time overhead less than 8%. Moreover, two case studies initially demonstrated the precision of DISTIA and its utility in distributed system understanding. While conservative thus subject to false positives, DISTIA balances precision and efficiency to offer costeffective options for evolving distributed programs. Socket ssock = null; 3 public S(int port) { ssock = new Socket(port); ssock.accept(); } 4 char getMax(String s) {...} 5 void serve() { String s = ssock.readLine(); 6 char r = getMax(s); ssock.writeChar(r); } 7 public static int main(String[] a) { 8 S s = new S(33); s.serve(); return 0; }} 9 public class C { 10 Socket csock = null; 11 public C(String host,int port) { csock = new Socket(host,port); } 12 void shuffle(String s) {...} 13 char compute(String s) { shuffle(s); csock.writeChars(s); 14 return csock.readChar(); } 15 public static int main(String[] a) { C c = new C('localhost',33); 16 System.out.println( c.compute(a[0]) ); return 0; }}

show abstract

“…In contrast, most later work on dynamic slicing 'defines' dynamic slicing based on the algorithms used to compute it (e.g., Agrawal et al [1] and Demillo et al [16]). Although many research prototypes and approaches exist [2], [6], [7], [36], [42], [53], [54], all approaches are for a single specific programming language whereas the observation based nature of ORBS allows it to slice programs distracted from multiple programming languages [10].…”

Section: Rq3: Observational Sensitivity To Inadequate Testingmentioning

confidence: 99%

ORBS and the limits of static slicing

Binkley

Gold

Harman

et al. 2015

2015 IEEE 15th International Working Conference on Source Code Analysis and Manipulation (SCAM)

View full text Add to dashboard Cite

Abstract-Observation-based slicing is a recently-introduced, language-independent, slicing technique based on the dependencies observable from program behaviour. Due to the wellknown 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 guaranteed to be 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 static minimal slice, where static techniques cannot. For more typical cases, our results illustrate the potential for observation-based slicing to highlight unsafe static slices. Finally, we report on the sensitivity of observation-based slicing to test quality.

show abstract

Dynamic slicing of distributed object-oriented programs

Cited by 22 publications

References 23 publications

ACCo: a novel approach to measure cohesion using hierarchical slicing of Java programs

ACCo: a novel approach to measure cohesion using hierarchical slicing of Java programs

DistIA: a cost-effective dynamic impact analysis for distributed programs

ORBS and the limits of static slicing

Contact Info

Product

Resources

About