A demand‐driven approach to slicing legacy COBOL systems

ACM Trans. Program. Lang. Syst.

Gold

Harman

et al. 2013

Several authors have found evidence of large dependence clusters in the source code of a diverse range of systems, domains, and programming languages. This raises the question of how we might efficiently locate the fragments of code that give rise to large dependence clusters. We introduce an algorithm for the identification of linchpin vertices, which hold together large dependence clusters, and prove correctness properties for the algorithm's primary innovations. We also report the results of an empirical study concerning the reduction in analysis time that our algorithm yields over its predecessor using a collection of 38 programs containing almost half a million lines of code. Our empirical findings indicate improvements of almost two orders of magnitude, making it possible to process larger programs for which it would have previously been impractical.

Section: Background: Large Dependence Clusters and Their Causessupporting

confidence: 81%

Efficient Identification of Linchpin Vertices in Dependence Clusters

ACM Trans. Program. Lang. Syst.

Gold

Harman

et al. 2013

“…During the ensuing decade, studies have replicated the initial findings with C programs, uncovering clusters in Java codes [9]- [11] and in legacy Cobol systems [12]. Dependence clusters are also known to be detrimental to the software development process where they hinder a variety of activities including maintenance, testing, and comprehension [13]- [17].…”

Section: Introductionmentioning

confidence: 93%

“…There has been much interest in dependence clusters and clusters have been identified in various programming languages and systems [12], [13], [21]. Jiang et al [31] proposed the use of search-based program slicing to identify dependence structures in programs.…”

Section: Threats To Validitymentioning

confidence: 99%

Uncovering dependence clusters and linchpin functions

2015 IEEE International Conference on Software Maintenance and Evolution (ICSME)

Beszedes

Islam

et al. 2015

Abstract-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 effective proxies for the more expensive, finer-grained approaches.Finally, the linchpin analysis shows that linchpin functions can be effectively and automatically identified.

“…To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Slicing has many proposed applications, including testing [7,18], debugging [23,42], maintenance [15,16], re-engineering [8], reuse [3,9], comprehension [11,22,39] and refactoring [14]. However, full development of these applications will not occur unless slicing can be used to slice programs written in multiple languages.…”

Section: Introductionmentioning

confidence: 99%

ORBS: language-independent program slicing

Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering

Gold

Harman

et al. 2014

127

Current slicing techniques cannot handle systems written in multiple programming languages. Observation-Based Slicing (ORBS) is a language-independent slicing technique capable of slicing multilanguage systems, including systems which contain (third party) binary components. A potential slice obtained through repeated statement deletion is validated by observing the behaviour of the program: if the slice and original program behave the same under the slicing criterion, the deletion is accepted. The resulting slice is similar to a dynamic slice. We evaluate five variants of ORBS on ten programs of different sizes and languages showing that it is less expensive than similar existing techniques. We also evaluate it on bash and four other systems to demonstrate feasible large-scale operation in which a parallelised ORBS needs up to 82% less time when using four threads. The results show that an ORBS slicer is simple to construct, effective at slicing, and able to handle systems written in multiple languages without specialist analysis tools.