8 research outputs found
Slicing for Java Program: A Preliminary Study
Program slicing is a technique that proposed to help in understanding the program code. After several decades, the technique has been derived into several other techniques and proposed to be applied in many fields such as debugging, program comprehension, software measurement, testing and maintenance. The application of program slicing sometimes specifies for certain programming language such as C and Java. This paper will discuss existing program slicing techniques that were proposed focusing on the Java programming language
Uncovering Dependence Clusters and Linchpin Functions
Dependence clusters are (maximal) collections of
mutually dependent source code entities according to some
dependence relation. Their presence in software complicates
many maintenance activities including testing, refactoring, and
feature extraction. Despite several studies finding them common
in production code, their formation, identification, and overall
structure are not well understood, partly because of challenges
in approximating true dependences between program entities.
Previous research has considered two approximate dependence
relations: a fine-grained statement-level relation using control
and data dependences from a programâs System Dependence
Graph and a coarser relation based on function-level controlflow
reachability. In principal, the first is more expensive and
more precise than the second.
Using a collection of twenty programs, we present an empirical
investigation of the clusters identified by these two approaches.
In support of the analysis, we consider hybrid cluster types
that works at the coarser function-level but is based on the
higher-precision statement-level dependences. The three types
of clusters are compared based on their slice sets using two
clustering metrics. We also perform extensive analysis of the
programs to identify linchpin functions â functions primarily
responsible for holding a cluster together. Results include evidence
that the less expensive, coarser approaches can often be used as
eïżœective proxies for the more expensive, finer-grained approaches.
Finally, the linchpin analysis shows that linchpin functions can
be eïżœectively and automatically identified
Verifying the concept of union slices on Java programs
Static program slicing is often proposed for software maintenance-related tasks. Due to different causes static slices are in many cases overly conservative and hence too large to reduce the program-part of interest meaningfully. In this paper we further investigate the concept of union slices, which are defined as the unions of dynamic slices computed for the same (static) slicing criteria, but for different executions of the program. We verify on real-world Java programs their usefulness as a replacement to static slices. For this we investigate the sizes of a number of backward and forward dynamic and union slices, also by comparing them to the corresponding static slices. Our results show that the union slices are precise enough (backward slices are 5â20 % of the program and forward slices are 5â 10%, the corresponding static slices being 25â45%), and that with the saturation of the overall coverage given many different executions, union slices also reach a steady level and typically do not grow further by adding new test cases
Coherent Dependence Cluster
This thesis introduces coherent dependence clusters and shows their relevance in areas of software engineering such as program comprehension and mainte- nance. All statements in a coherent dependence cluster depend upon the same set of statements and affect the same set of statements; a coherent clusterâs statements have âcoherentâ shared backward and forward dependence. We introduce an approximation to efficiently locate coherent clusters and show that its precision significantly improves over previous approximations. Our empirical study also finds that, despite their tight coherence constraints, coherent dependence clusters are to be found in abundance in production code. Studying patterns of clustering in several open-source and industrial programs reveal that most contain multiple significant coherent clusters. A series of case studies reveal that large clusters map to logical functionality and pro- gram structure. Cluster visualisation also reveals subtle deficiencies of program structure and identify potential candidates for refactoring efforts. Supplemen- tary studies of inter-cluster dependence is presented where identification of coherent clusters can help in deriving hierarchical system decomposition for reverse engineering purposes. Furthermore, studies of program faults find no link between existence of coherent clusters and software bugs. Rather, a longi- tudinal study of several systems find that coherent clusters represent the core architecture of programs during system evolution. Due to the inherent conservativeness of static analysis, it is possible for unreachable code and code implementing cross-cutting concerns such as error- handling and debugging to link clusters together. This thesis studies their effect on dependence clusters by using coverage information to remove unexecuted and rarely executed code. Empirical evaluation reveals that code reduction yields smaller slices and clusters