Keith Gallagher

Using program slicing in software maintenance

Program slicing is applied to the software maintenance problem by extending the notion of a program slice (that originally required both a variable and line number) to a decomposition slice, one that captures all computation on a given variable, i.e., is independent of line numbers. Using the lattice of single variable decomposition slices ordered by set inclusion, it is shown how a slice-based decomposition for programs can be formed. One can then delineate the effects of a proposed change by isolating those effects in a single component of the decomposition. This gives maintainers a straightforward technique for determining those statements and variables which may be modified in a component and those which may not. Using the decomposition, a set of principles to prohibit changes which will interfere with unmodified components is provided. These semantically consistent changes can then be merged back into the original program in linear time. >

Dependence clusters in source code

A dependence cluster is a set of program statements, all of which are mutually inter-dependent. This article reports a large scale empirical study of dependence clusters in C program source code. The study reveals that large dependence clusters are surprisingly commonplace. Most of the 45 programs studied have clusters of dependence that consume more than 10% of the whole program. Some even have clusters consuming 80% or more. The widespread existence of clusters has implications for source code analyses such as program comprehension, software maintenance, software testing, reverse engineering, reuse, and parallelization.

Overlapping Community Detection by Collective Friendship Group Inference

There has been considerable interest in improving the capability to identify communities within large collections of social networking data. However, many of the existing algorithms will compartment an actor (node) into a single group, ignoring the fact that in real-world situations people tend to belong concurrently to multiple groups. Our work focuses on the ability to find overlapping communities by aggregating the community perspectives of friendship groups, derived from egonets. We will demonstrate that our algorithm not only finds overlapping communities, but additionally helps identify key members, which bind communities together. Additionally, we will highlight the parallel feature of the algorithm as a means of improving runtime performance.

An architecture for interoperable program understanding tools

Program understanding tools are currently not interoperable, leading researchers to waste significant resources reinventing already existing tools. Even commercial environments that have been designed to support the construction of program understanding tools have serious flaws in this regard. This paper discusses CORUM (Common Object-based Re-engineering Unified Model), an architecture to support interoperability between program understanding tools, and it provides several examples of CORUMs use in the construction of new tools for concept recognition and program visualization.

Evaluating the Surgeon's Assistant: results of a pilot study

The author reports on an empirical evaluation of decomposition slicing as a maintenance method as implemented in the Surgeons Assistant. The improvement-oriented software maintenance model presented by H. D. Rombach and B.T. Ulery (1988) is used as the foundation. A reprise of software process modeling, a short introduction to software maintenance process modeling, and the definition of the evaluation model are presented. Decomposition slicing induces changes in the standard maintenance model; the evaluation attempts to measure the effectiveness of the induced model as compared with the standard one. The evaluation is a pilot study. A preliminary comparison is made using certain defined metrics. This yields some insights into the strengths and weaknesses of the tool and its applicability in certain scenarios.<<ETX>>

Software Architecture Visualization: An Evaluation Framework and Its Application

In order to characterize and improve software architecture visualization practice, the paper derives and constructs a qualitative framework, with seven key areas and 31 features, for the assessment of software architecture visualization tools. The framework is derived by the application of the Goal Question Metric paradigm to information obtained from a literature survey and addresses a number of stakeholder issues. The evaluation is performed from multiple stakeholder perspectives and in various architectural contexts. Stakeholders can apply the framework to determine if a particular software architecture visualization tool is appropriate to a given task. The framework is applied in the evaluation of a collection of six software architecture visualization tools. The framework may also be used as a design template for a comprehensive software architecture visualization tool.

Overlapping community detection using a community optimized graph swarm

Detection of communities within social networks is a nontrivial problem. Allowing communities to overlap—i.e. nodes can belong to more than one community simultaneously—further complicates the problem. Nevertheless, people do belong to multiple social groups simultaneously and being able to detect overlapping communities is an important step into being able to understand and analyze social networks. A common practice in community detection (clustering) is to view the network (graph) as a whole and have a central control process determine how nodes are clustered. That central control, we believe, is a limitation to performance. In our previous work, we showed that the individual’s view of his or hers social groups could be aggregated to produce communities. In this paper, we propose a unique approach to community detection that combines the individual’s view of a community, not having the view the graph as a whole, with swarm intelligence as a means of removing the central control mechanism. Our approach offers a community detection solution that finds overlapping communities while running in O(n log2n) time.

Using program decomposition to guide modifications

The authors use data-flow techniques to form a notion of direct sum decomposition for programs. The decomposition yields a method and guidelines for software maintainers to use so that changes can be assured to be completely contained in the modules under consideration and that there are no undetected linkages between the modified and unmodified code. Thus, the impact of small changes can be gauged. The decomposition can also be used to limit the amount of testing required to assure that the change is correct; under suitable conditions, modification testing will be required only for the changed code. Moreover, if these hypotheses are violated, the modifier can be virtually assured that proposed changes will have a wider impact than that which is contemplated.<<ETX>>

Are decomposition slices clones

When computing program slices on all variables in a system, we observed that many of these slices are the same. This leads to the question: Are we looking at software clones? We discuss the genesis of this phenomena and present some of the data observations that led to the question. The answer to our query is not immediately clear. We end by presenting arguments both pro and con. Supporting the affirmative, we observed that some slice-clones are evidently the result of the usual genesis of software clones: failure to note appropriate abstractions. Also, slice-clones assist in program comprehension by coalescing into one program fragment the computations on many different variables. Opposing the proposition, we note that slice-clones do not arise due to programmer intent or the copying of existing idioms.

A Framework for Software Architecture Visualisation Assessment

In order to assess software architecture visualisation strategies, we qualitatively characterize then construct an assessment framework with 7 key areas and 31 features. The framework is used for evaluation and comparison of various strategies from multiple stakeholder perspectives. Six existing software architecture visualisation tools and a seventh research tool were evaluated. All tools exhibited shortcomings when evaluated in the framework