Search

Slicing is a technique, traditionally applied to programs, for extracting the parts of a program that affect the values computed at a statement of interest. In recent years authors have begun to consider slicing at model level. We present a detailed review of existing work on slicing at the level of finite-state-machine-based models. We focus on state-based modeling notations because these have received sufficient attention from the slicing community that there is now a coherent body of hitherto unsurveyed work. We also identify the challenges that state-based slicing presents and how the existing literature has addressed these. We conclude by identifying problems that remain open either because of the challenges involved in addressing them or because the community simply has yet to turn its attention to solving them [ABSTRACT FROM AUTHOR]

Abstract: We introduce a new non-strict semantics for a simple while language. We demonstrate that this semantics allows us to give a denotational definition of variable dependence and neededness, which is consistent with program slicing. Unlike other semantics used in variable dependence, our semantics is substitutive. We prove that our semantics is preserved by traditional slicing algorithms. [Copyright &y& Elsevier]

Aspect-Oriented Programming (AOP) provides mechanisms for the separation of crosscutting concerns--functionalities scattered through the system and tangled with the base code. Existing systems are a natural test-bed for the AOP approach since they often contain several crosscutting concerns which could not be modularized using traditional programming constructs. This paper presents an automated approach to the problem of migrating systems developed according to the Object-Oriented Programming (OOP) paradigm into Aspect-Oriented Programming (AOP). A simple set of six refactorings has been defined to transform OOP to AOP and has been implemented in the AOP-Migrator tool, an Eclipse plug-in. A set of enabling transformations from OOP to OOP complement the initial set of refactorings. The paper presents the results of four case studies, which use the approach to migrate selected crosscutting concerns from medium-sized Java programs (in the range of 10K to 40K lines of code) into equivalent programs in AspectJ. The case study results show the feasibility of the migration and indicate the importance of the enabling transformations as a preprocessing step. [ABSTRACT FROM AUTHOR]

An amorphous slice of a program is constructed with respect to a set of variables. The amorphous slice is an executable program which preserves the behaviour of the original on the variables of interest. Unlike syntax-preserving slices, amorphous slices need not preserve a projection of the syntax of a program. This makes the task of amorphous slice construction harder, but it also often makes the result thinner and thereby preferable in applications where syntax preservation is unimportant. This paper describes an approach to the construction of amorphous slices which is based on the Abstract Syntax Tree of the program to be sliced, and does not require the construction of control flow graphs nor of program dependence graphs. The approach has some strengths and weaknesses which the paper discusses. The amorphous slicer, is part of the GUSTT slicing system, which includes syntax preserving static and conditioned slicers, a side effect removal transformation phase, slicing criterion guidance and for which much of the correctness proofs for transformation steps are mechanically verified. The system handles a subset of WSL, into which more general WSL constructs can be transformed. The paper focuses upon the way in which the GUSTT System uses dependence reduction transformation tactics. Such dependence reduction is at the heart of all approaches to amorphous slicing. The algorithms used are described and their performance is assessed with a simple empirical study of best and worst case execution times for an implementation built on top of the FermaT transformation system for maintenance and re-engineering. [ABSTRACT FROM AUTHOR]

This paper describes the use of conditioned slicing to assist partition testing, illustrating this with a case study. The paper shows how a conditioned slicing tool can be used to provide confidence in the uniformity hypothesis for correct programs, to aid fault detection in incorrect programs and to highlight special cases. Copyright © 2001 John Wiley & Sons, Ltd [ABSTRACT FROM AUTHOR]

While mutation testing has proved to be an effective way of finding software faults, currently it is only applied to relatively small programs. One of the main reasons for this is the human analysis required in detecting equivalent mutants. Here program slicing is used to simplify this problem. Progam slicing is also used to reduce the number of equivalent mutants produced. Copyright © 1999 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Program slicing is an automatic program abstraction technique whose many applications include software maintenance, re-engineering and comprehension, all of which rely crucially upon the precision of the slicing algorithm used. When slicing is applied to maintenance problems, the programs to be sliced are typically legacy systems, often written in older, `unstructured' programming styles. For slicing to be a useful tool to the software maintainer it is therefore important to have precise algorithms for slicing unstructured programs. Unfortunately the standard algorithms for slicing structured programs do not extend correctly to the unstructured paradigm, and currently proposed modifications to these standard algorithms produce either unnecessarily large slices or slices which are not true subsets of the original program from which they are constructed. This paper introduces a modification of Agrawal's algorithm for slicing unstructured programs, which overcomes these difficulties. The new algorithm produces thinner slices than any previously published algorithm while respecting both the semantic and syntactic constraints of slicing. [ABSTRACT FROM AUTHOR]

The article presents information on the 20th anniversary of the IEEE International Conference on Software Maintenance (ICSM). Software maintenance and evolution continues to play a vital role in the development of software systems. For many years there has been an international effort among researchers and practitioners to control the costs associated with software maintenance and evolution and to improve the quality of the processes and products associated with this vital activity. Software maintenance encompasses human elements of software engineering, which require psychological, statistical, and empirical evaluation. It involves algorithms, methods, and techniques which require a deep understanding of all activities in the software development life cycle. Since its inception in 1983, ICSM has evolved into an international forum for researchers, practitioners, educators, technology transfer experts, project managers, tool developers, and users who explore current issues facing the computing community. In 2004, the ICSM program chairs, Mark Harman from King's College in London and Bogdan Korel from Illinois institute of Technology in Chicago, selected 38 papers for inclusion in the proceedings from 122 submissions.

A foreword to a paper on automatic software repair published in the current issue is presented.

Mutation Testing is a fault-based software testing technique that has been widely studied for over three decades. The literature on Mutation Testing has contributed a set of approaches, tools, developments, and empirical results. This paper provides a comprehensive analysis and survey of Mutation Testing. The paper also presents the results of several development trend analyses. These analyses provide evidence that Mutation Testing techniques and tools are reaching a state of maturity and applicability, while the topic of Mutation Testing itself is the subject of increasing interest. [ABSTRACT FROM AUTHOR]

Abstract: We define a program semantics that is preserved by dependence-based slicing algorithms. It is a natural extension, to non-terminating programs, of the semantics introduced by Weiser (which only considered terminating ones) and, as such, is an accurate characterisation of the semantic relationship between a program and the slice produced by these algorithms. Unlike other approaches, apart from Weiser’s original one, it is based on strict standard semantics which models the ‘normal’ execution of programs on a von Neumann machine and, thus, has the advantage of being intuitive. This is essential since one of the main applications of slicing is program comprehension. Although our semantics handles non-termination, it is defined wholly in terms of finite trajectories, without having to resort to complex, counter-intuitive, non-standard models of computation. As well as being simpler, unlike other approaches to this problem, our semantics is substitutive. Substitutivity is an important property because it greatly enhances the ability to reason about correctness of meaning-preserving program transformations such as slicing. [Copyright &y& Elsevier]

Abstract: The widespread interest in program slicing within the source code analysis and manipulation community has led to the introduction of a large number of different forms of slicing. Each preserves some aspect of a program’s behaviour and simplifies the program to focus exclusively upon this behaviour. In order to understand the similarities and differences between forms of slicing, a formal mechanism is required. This paper further develops a formal framework for comparing forms of slicing using a theory of program projection. This framework is used to reveal the ordering relationship between various static, dynamic, simultaneous and conditioned forms of slicing. [Copyright &y& Elsevier]