24 research outputs found
Pre/post conditioned slicing
Th paper shows how analysis of programs in terms of pre- and postconditions can be improved using a generalisation of conditioned program slicing called pre/post conditioned slicing. Such conditions play an important role in program comprehension, reuse, verification and reengineering. Fully automated analysis is impossible because of the inherent undecidability of pre- and post- conditions. The method presented reformulates the problem to circumvent this. The reformulation is constructed so that programs which respect the pre- and post-conditions applied to them have empty slices. For those which do not respect the conditions, the slice contains statements which could potentially break the conditions. This separates the automatable part of the analysis from the human analysis
ConSIT: A conditioned program slicer
Conditioned slicing is a powerful generalisation of static and dynamic slicing which has applications to many problems in software maintenance and evolution, including reuse, reengineering and program comprehension. However there has been relatively little work on the implementation of conditioned slicing. Algorithms for implementing conditioned slicing necessarily involve reasoning about the values of program predicates in certain sets of states derived from the conditioned slicing criterion, making implementation particularly demanding. The paper introduces ConSIT, a conditioned slicing system which is based upon conventional static slicing, symbolic execution and theorem proving. ConSIT is the first fully automated implementation of conditioned slicing. An implementation of ConSIT is available for experimentation at &http://www.mcs.gold.ac.uk/tilde/~mas01sd/consit.htm
Pattern-based refactoring in model-driven engineering
L’ingénierie dirigée par les modèles (IDM) est un paradigme du génie logiciel qui utilise les
modèles comme concepts de premier ordre à partir desquels la validation, le code, les tests
et la documentation sont dérivés. Ce paradigme met en jeu divers artefacts tels que les
modèles, les méta-modèles ou les programmes de transformation des modèles. Dans un
contexte industriel, ces artefacts sont de plus en plus complexes. En particulier, leur
maintenance demande beaucoup de temps et de ressources. Afin de réduire la complexité
des artefacts et le coût de leur maintenance, de nombreux chercheurs se sont intéressés au
refactoring de ces artefacts pour améliorer leur qualité.
Dans cette thèse, nous proposons d’étudier le refactoring dans l’IDM dans sa
globalité, par son application à ces différents artefacts. Dans un premier temps, nous
utilisons des patrons de conception spécifiques, comme une connaissance a priori, appliqués
aux transformations de modèles comme un véhicule pour le refactoring. Nous procédons
d’abord par une phase de détection des patrons de conception avec différentes formes et
différents niveaux de complétude. Les occurrences détectées forment ainsi des opportunités
de refactoring qui seront exploitées pour aboutir à des formes plus souhaitables et/ou plus
complètes de ces patrons de conceptions.
Dans le cas d’absence de connaissance a priori, comme les patrons de conception,
nous proposons une approche basée sur la programmation génétique, pour apprendre des
règles de transformations, capables de détecter des opportunités de refactoring et de les
corriger. Comme alternative à la connaissance disponible a priori, l’approche utilise des
exemples de paires d’artefacts d’avant et d’après le refactoring, pour ainsi apprendre les
règles de refactoring. Nous illustrons cette approche sur le refactoring de modèles.Model-Driven Engineering (MDE) is a software engineering paradigm that uses models as
first-class concepts from which validation, code, testing, and documentation are derived.
This paradigm involves various artifacts such as models, meta-models, or model
transformation programs. In an industrial context, these artifacts are increasingly complex.
In particular, their maintenance is time and resources consuming. In order to reduce the
complexity of artifacts and the cost of their maintenance, many researchers have been
interested in refactoring these artifacts to improve their quality.
In this thesis, we propose to study refactoring in MDE holistically, by its application
to these different artifacts. First, we use specific design patterns, as an example of prior
knowledge, applied to model transformations to enable refactoring. We first proceed with a
detecting phase of design patterns, with different forms and levels of completeness. The
detected occurrences thus form refactoring opportunities that will be exploited to implement
more desirable and/or more complete forms of these design patterns.
In the absence of prior knowledge, such as design patterns, we propose an approach
based on genetic programming, to learn transformation rules, capable of detecting
refactoring opportunities and correcting them. As an alternative to prior knowledge, our
approach uses examples of pairs of artifacts before and after refactoring, in order to learn
refactoring rules. We illustrate this approach on model refactoring
Program Comprehension Through Sonification
Background: Comprehension of computer programs is daunting, thanks in part to clutter in the software developer's visual environment and the need for frequent visual context changes. Non-speech sound has been shown to be useful in understanding the behavior of a program as it is running.
Aims: This thesis explores whether using sound to help understand the static structure of programs is viable and advantageous.
Method: A novel concept for program sonification is introduced. Non-speech sounds indicate characteristics of and relationships among a Java program's classes, interfaces, and methods. A sound mapping is incorporated into a prototype tool consisting of an extension to the Eclipse integrated development environment communicating with the sound engine Csound. Developers examining source code can aurally explore entities outside of the visual context. A rich body of sound techniques provides expanded representational possibilities. Two studies were conducted. In the first, software professionals participated in exploratory sessions to informally validate the sound mapping concept. The second study was a human-subjects experiment to discover whether using the tool and sound mapping improve performance of software comprehension tasks. Twenty-four software professionals and students performed maintenance-oriented tasks on two Java programs with and without sound.
Results: Viability is strong for differentiation and characterization of software entities, less so for identification. The results show no overall advantage of using sound in terms of task duration at a 5% level of significance. The results do, however, suggest that sonification can be advantageous under certain conditions.
Conclusions: The use of sound in program comprehension shows sufficient promise for continued research. Limitations of the present research include restriction to particular types of comprehension tasks, a single sound mapping, a single programming language, and limited training time. Future work includes experiments and case studies employing a wider set of comprehension tasks, sound mappings in domains other than software, and adding navigational capability for use by the visually impaired
Runtime visualisation of object-oriented software
Software is a complex and invisible entity, yet one which is core to modem life. The development and maintenance of such software includes one staple task, the need to understand the software at the implementation level. This process of program comprehension is difficult and time consuming. Yet, despite its importance, there remains very limited tool support for program comprehension activities. The results of this research show the role that runtime visualisation can play in aiding the comprehension of object-oriented software by highlighting both its static and dynamic structure. Previous work in this area is discussed, both in terms of the representations used and the methods of extracting runtime information. Building on this previous work, this thesis develops new representations of object-oriented software at runtime, which are then implemented in a proof of concept tool. This tool allowed the representations to be investigated on real software systems. The representations are evaluated against two feature-based evaluation frameworks. The evaluation focuses on generic software visualisation criteria, due to the lack of any specific frameworks for visualising dynamic information. The evaluation also includes lessons learnt in the implementation of a prototype visualisation tool. The object-oriented paradigm continues to grow in popularity and provides advantages to program comprehension activities. However, it also brings a number of new challenges to program comprehension due to the discrepancies between its static definition and its runtime structure. Therefore, techniques that highlight both the static definition and the runtime behaviour of object-oriented systems offer benefits to their comprehension. Software visualisation offers an approach to aid program comprehension activities through providing a means to deal with the size and complexity of the software and its invisible nature. This thesis highlights the generic issues that software visualisation faces, before focusing on how the visualisation of runtime information affects these issues. Many of the issues are compounded by the dynamic nature of the information to be visualised and the explosive growth in the volume of information that this dynamism can bring. Wider results of this research have allowed the proposal of the necessary concepts that should be considered in the design and evaluation of runtime visualisations. Software visualisation at runtime is still a relatively unexplored area and there remains many research challenges within it. This thesis aims to act as a first step to addressing these challenges and aims to promote interest and future development within this area