A study of code change patterns for adaptive maintenance with AST analysis

Example-based transformational approaches to automate adaptive maintenance changes plays an important role in software research. One primary concern of those approaches is that a set of good qualified real examples of adaptive changes previously made in the history must be identified, or otherwise the adoption of such approaches will be put in question. Unfortunately, there is rarely enough detail to clearly direct transformation rule developers to overcome the barrier of finding qualified examples for adaptive changes. This work explores the histories of several open source systems to study the repetitiveness of adaptive changes in software evolution, and hence recognizing the source code change patterns that are strongly related with the adaptive maintenance. We collected the adaptive commits from the history of numerous open source systems, then we obtained the repetitiveness frequencies of source code changes based on the analysis of Abstract Syntax Tree (AST) edit actions within an adaptive commit. Using the prevalence of the most common adaptive changes, we suggested a set of change patterns that seem correlated with adaptive maintenance. It is observed that 76.93% of the undertaken adaptive changes were represented by 12 AST code differences. Moreover, only 9 change patterns covered 64.69% to 76.58% of the total adaptive change hunks in the examined projects. The most common individual patterns are related to initializing objects and method calls changes. A correlation analysis on examined projects shows that they have very similar frequencies of the patterns correlated with adaptive changes. The observed repeated adaptive changes could be useful examples for the construction of transformation approache

Optimization within a Unified Transformation Framework

Programmers typically want to write scientific programs in a high level language with semantics based on a sequential execution model. To execute efficiently on a parallel machine, however, a program typically needs to contain explicit parallelism and possibly explicit communication and synchronization. So, we need compilers to convert programs from the first of these forms to the second. There are two basic choices to be made when parallelizing a program. First, the computations of the program need to be distributed amongst the set of available processors. Second, the computations on each processor need to be ordered. My contribution has been the development of simple mathematical abstractions for representing these choices and the development of new algorithms for making these choices. I have developed a new framework that achieves good performance by minimizing communication between processors, minimizing the time processors spend waiting for messages from other processors, and ordering data accesses so as to exploit the memory hierarchy. This framework can be used by optimizing compilers, as well as by interactive transformation tools. The state of the art for vectorizing compilers is already quite good, but much work remains to bring parallelizing compilers up to the same standard. The main contribution of my work can be summarized as improving this situation by replacing existing ad hoc parallelization techniques with a sound underlying foundation on which future work can be built. (Also cross-referenced as UMIACS-TR-96-93

Semi-Automatische Deduktion von Feature-Lokalisierung während der Softwareentwicklung: Masterarbeit

Despite extensive research on software product lines in the last decades, ad-hoc clone-and-own development is still the dominant way for introducing variability to software systems. Therefore, the same issues for which software product lines were developed in the first place are still imminent in clone-and-own development: Fixing bugs consistently throughout clones and avoiding duplicate implementation effort is extremely diffcult as similarities and differences between variants are unknown. In order to remedy this, we enhance clone-and-own development with techniques from product-line engineering for targeted variant synchronisation such that domain knowledge can be integrated stepwise and without obligation. Contrary to retroactive feature mapping recovery (e.g., mining) techniques, we infer feature-to-code mappings directly during software development when concrete domain knowledge is present. In this thesis, we focus on the first step towards targeted synchronisation between variants: the recording of feature mappings. By letting developers specify on which feature they are working on, we derive feature mappings directly during software development. We ensure syntactic validity of feature mappings and variant synchronisation by implementing disciplined annotations through abstract syntax trees. To bridge the mismatch between change classification in the implementation and abstract layer, we synthesise semantic edits on abstract syntax trees. We show that our derivation can be used to reproduce variability-related real-world code changes and compare it to the feature mapping derivation of the projectional variation control system VTS by Stanciulescu et al.Trotz umfangreicher Forschung zu Software-Produktlinien in den letzten Jahrzehnten ist Clone-and-Own immer noch der dominierende Ansatz zur Einführung von Variabilität in Softwaresystemen. Daher stehen bei Clone-and-Own immer noch die gleichen Probleme im Vordergrund, für die Software-Produktlinien überhaupt erst entwickelt wurden: Die konsistente Behebung von Fehlern in allen Klonen und die Vermeidung von doppeltem Implementierungsaufwand sind äußerst schwierig, da Ähnlichkeiten und Unterschiede zwischen den Varianten unbekannt sind. Um hier Abhilfe zu schaffen, erweitern wir die Clone-and-Own-Entwicklung mit Techniken aus der Produktlinien-Entwicklung zur gezielten Synchronisierung von Varianten, sodass Entwickler ihr Domänenwissen schrittweise und unverbindlich integrieren können. Im Gegensatz zu nachträglich arbeitenden Feature-Mapping-Recovery- oder auch Mining-Techniken, leiten wir Zuordungen von Features zu Quellcode direkt während der Softwareentwicklung ab, wenn konkretes Domänenwissen vorhanden ist. In dieser Arbeit entwickeln wir den ersten Schritt zur gezielten Synchronisation von Varianten: die Aufzeichnung von Feature-Mappings. Indem Entwickler spezifizieren an welchem Feature sie arbeiten, leiten wir Feature-Mappings direkt während der Softwareentwicklung ab. Wir stellen die syntaktische Korrektheit von Feature-Mappings und der Synchronisation von Varianten sicher, indem wir disziplinierte Annotationen mithilfe von abstrakten Syntaxbäumen implementieren. Um die Diskrepanz der Klassifizierung von Änderungen zwischen der Implementierungs- und der Abstraktionsschicht zu überbrücken, synthetisieren wir Semantic Edits auf abstrakten Syntaxbäumen. Wir zeigen, dass unsere Ableitung von Feature-Mappings in der Lage ist reale Codeänderungen zu reproduzieren und vergleichen sie mit der Feature-Mapping-Ableitung des Variationskontrollsystems VTS von Stanciulescu et al

A Transformational Reengineering System That Supports Software Maintenance Using a Graph Representation for the Identification of an Object-Oriented Software Architecture.

The process of maintenance and enhancement of legacy software systems is a laborious and unavoidable task. Often these systems lack structure or modularity, as they were developed using programming languages and paradigms that do not incorporate object-oriented features and sound design principles. The software engineer\u27s task can be simplified if tools are available to identify object like features in the code. These tools can help transform the non-object-oriented code to object oriented code. This research describes a comprehensive and systematic process for transformational reengineering of legacy systems. Research in reengineering is mainly focused on clustering techniques that group procedures present in the legacy system into candidate objects. These clustering approaches are limited to systems with well-defined data structures and procedures. Several of these approaches are either not comprehensive, limited to certain types of systems, or depend extensively on engineer knowledge of the system. Unlike these approaches that analyze legacy systems at the procedural level, the reengineering process we present analyzes systems at the statement level. This process results in the identification of object operations. These operations, along with the state variables and the user defined data structures, are arranged in a hierarchy that represents the object structure of the reengineered variant of the legacy system. From this system hierarchy, objects are identified and encapsulated by streamlining the interfaces. The reengineering process is incorporated in a tool, ReArchitect. Programs are statically analyzed and represented as a statement dependence graph (StDG) for further processing. The StDG is a fine-grained representation with modular representation for functions and program slices. It can adapt to program changes, unlike other representations. The StDG is restructured by merging cohesive components in the graph. The restructured graph is used to build the object structure, which is used to identify the objects. The StDG is a theoretically sound framework that provides support for many problems found in the reengineering domain. We show the value of the StDG in two such domains: program slicing and maintenance. The StDG is restructured differently for different requirements (space/time), and for different types of applications

Studies in the linguistic sciences. 08 (1978)

MLA international bibliography of books and articles on the modern languages and literatures (Complete edition) 0024-821

Creative problem solving and automated discovery : an analysis of psychological and AI research

Since creativity is the ability to produce something novel and unexpected, it has always fascinated people. Consequently, efforts have been made in AI to invent creative computer programs. At the same time much effort was spent in psychology to analyze the foundations of human creative behaviour. However, until now efforts in AI to produce creative programs have been largely independent from psychological research. In this study, we try to combine both fields of research. First, we give a short summary of the main results of psychological research on creativity. Based on these results we propose a model of the creative process that emphasizes its information processing aspects. Then we describe AI approaches to the implementation of the various components of this model and contrast them with the results of psychological research. As a result we will not only reveal weaknesses of current AI systems hindering them in achieving creativity, but we will also make plausible suggestions - based on psychological research - for overcoming these weaknesses