Automatically transforming GNU C Source Code

Proceedings of the 1st International Workshop on Software Evolution Transformations (SET'04), Delft, The Netherlands, November, 2004. Retrieved 3/16/2006 from http://www.cs.drexel.edu/~spiros/research/papers/SET04.pdf.To perform automated transformation techniques on production quality GNU C source code, non-trivial normalizations must occur. The syntax of GNU C contains inherent ambiguity that must be overcome. The techniques used by an automated transformation tool, Gemini, are presented

A hierarchy of dynamic software views: from object-interactions to feature-interactions

Proceedings of the 2004 International Conference on Software Maintenance (ICSM'04), Chicago, Ill., September 2004. Retrieved 3/16/2006 from http://www.cs.drexel.edu/~spiros/research/papers/ICSM04.pdf.This paper presents a hierarchy of dynamic views that is constructed using tools that analyze program execution traces. At the highest-level of abstraction are the featureinteraction and implementation views, which track the interfeature dependencies as well as the classes that implement these features. At the middle-level is the class-interaction view, which is an abstract view of the object-interactions. The object-interaction view is the base view for all the views, and captures the low-level runtime interactions between objects. Two case studies are used to demonstrate the effectiveness of our work

Guest editors’ introduction to the special section from the international conference on software maintenance and evolution

IEEE Transactions on Software Engineering, 33(12): pp. 797-798

On computing the canonical features of software systems

Paper presented at the 13th Working Conference on Reverse Engineering, WCRE 2006, Benevento, Italy.Software applications typically have many features that vary in their similarity. We define a measurement of similarity between pairs of features based on their underlying implementations and use this measurement to compute a set of canonical features. The Canonical Features Set (CFS) consists of a small number of features that are as dissimilar as possible to each other, yet are most representative of the features that are not in the CFS. The members of the CFS are distinguishing features and understanding their implementation provides the engineer with an overview of the system undergoing scrutiny. The members of the CFS can also be used as cluster centroids to partition the entire set of features. Partitioning the set of features can simplify the understanding of large and complex software systems. Additionally, when a specific feature must undergo maintenance, it is helpful to know which features are most closely related to it. We demonstrate the utility of our method through the analysis of the Jext, Firefox, and Gaim software systems

Towards employing use-cases and dynamic analysis to comprehend Mozilla

Proceedings of the 2005 International Conference on Software Maintenance (ICSM'05), Budapest, Hungary, September, 2005. Retrieved 3/16/2006 from http://www.cs.drexel.edu/~spiros/research/papers/ICSM05b.pdf.This paper presents an approach for comprehending large software systems using views that are created by subjecting the software systems to dynamic analysis under various use-case scenarios. Two sets of views are built from the runtime data: (1) graphs that capture the parts of the software's architecture that pertain to the use-cases; and (2) metrics that measure the intricacy of the software and the similarity between the software's use-cases. The Mozilla web browser was chosen as the subject software system in our case study due to its size, intricacy, and ability to expose the challenges of analyzing large systems

Scenariographer: a tool for reverse engineering class usage scenarios from method invocation sequences

Proceedings of the 2005 International Conference on Software Maintenance (ICSM'05), Budapest, Hungary, September, 2005. Retrieved 3/16/2006 from http://www.cs.drexel.edu/~spiros/research/papers/ICSM05a.pdfTypical documentation for object-oriented programs includes descriptions of the parameters and return types of each method in a class, but little or no information on valid method invocation sequences. Knowing the sequence with which methods of a class can be invoked is useful information especially for software engineers (e.g., developers, testers) who are actively involved in the maintenance of large software systems. This paper describes a new approach and a tool for generating class usage scenarios (i.e., how a class is used by other classes) from method invocations, which are collected during the execution of the software. Our approach is algorithmic and employs the notion of canonical sets to categorize method sequences into groups of similar sequences, where each group represents a usage scenario for a given class

Studying the evolution of software systems using change clusters

Thirteenth International Symposium on Temporal Representation and Reasoning, TIME 2006, Athens, Greece.In this paper, we present an approach that examines the evolution of code stored in source control repositories. The technique identifies Change Clusters which can help managers to classify different code change activities as software maintenance or new development. Furthermore, identifying the variations in Change Clusters over time exposes trends in the development of a software system. We present a case study, which uses a sequence of Change Clusters to track the evolution of the PostgreSQL software project. Our case study demonstrates that our technique reveals interesting patterns about the progress of code development within each release of PostgreSQL. We show that the increase in the number of clusters not only identifies the areas where development has occurred, but reflects the magnitude of change in code. We also compare how the Change Clusters vary over time in order to make generalizations about the focus of development

Search based software engineering: Trends, techniques and applications

© ACM, 2012. This is the author's version of the work. It is posted here by permission of ACM for your personal use. Not for redistribution. The definitive version is available from the link below.In the past five years there has been a dramatic increase in work on Search-Based Software Engineering (SBSE), an approach to Software Engineering (SE) in which Search-Based Optimization (SBO) algorithms are used to address problems in SE. SBSE has been applied to problems throughout the SE lifecycle, from requirements and project planning to maintenance and reengineering. The approach is attractive because it offers a suite of adaptive automated and semiautomated solutions in situations typified by large complex problem spaces with multiple competing and conflicting objectives. This article provides a review and classification of literature on SBSE. The work identifies research trends and relationships between the techniques applied and the applications to which they have been applied and highlights gaps in the literature and avenues for further research.EPSRC and E

Reformulating software engineering as a search problem

Metaheuristic techniques such as genetic algorithms, simulated annealing and tabu search have found wide application in most areas of engineering. These techniques have also been applied in business, financial and economic modelling. Metaheuristics have been applied to three areas of software engineering: test data generation, module clustering and cost/effort prediction, yet there remain many software engineering problems which have yet to be tackled using metaheuristics. It is surprising that metaheuristics have not been more widely applied to software engineering; many problems in software engineering are characterised by precisely the features which make metaheuristics search applicable. In the paper it is argued that the features which make metaheuristics applicable for engineering and business applications outside software engineering also suggest that there is great potential for the exploitation of metaheuristics within software engineering. The paper briefly reviews the principal metaheuristic search techniques and surveys existing work on the application of metaheuristics to the three software engineering areas of test data generation, module clustering and cost/effort prediction. It also shows how metaheuristic search techniques can be applied to three additional areas of software engineering: maintenance/evolution system integration and requirements scheduling. The software engineering problem areas considered thus span the range of the software development process, from initial planning, cost estimation and requirements analysis through to integration, maintenance and evolution of legacy systems. The aim is to justify the claim that many problems in software engineering can be reformulated as search problems, to which metaheuristic techniques can be applied. The goal of the paper is to stimulate greater interest in metaheuristic search as a tool of optimisation of software engineering problems and to encourage the investigation and exploitation of these technologies in finding near optimal solutions to the complex constraint-based scenarios which arise so frequently in software engineering