Abstract not found

Schema evolution is a problem that is faced by long-lived data. When a schema changes, existing persistent data can become inaccessible unless the database system provides mechanisms to access data created with previous versions of the schema. Most existing systems that support schema evolution focus on changes local to individual types within the schema, thereby limiting the changes that the database maintainer can perform. We have developed a model of type changes incorporating changes local to individual types as well as compound changes involving multiple types. The model describes both type changes and their impact on data by defining derivation rules to initialize new data based on the existing data. The derivation rules can describe local and nonlocal changes to types to capture the intent of a large class of type change operations. We have built a system called Tess (Type Evolution Software System) that uses this model to recognize type changes by comparing schemas and then produces a transformer that can update data in a database to correspond to a newer version of the schema.

The increased popularity of the object-oriented paradigm has also increased the interest in object-oriented reengineering. First of all, object-oriented software systems suffer from similar maintainability problems as traditional procedural systems, displaying the need for reengineering techniques tailored to deal with ob- ject-oriented code. Secondly, the increased importance of iterative development processes make reengi- neering techniques valuable in forward engineering, and thus for all paradigms that software is developed in. Reengineering requires tool support to deal with the large amounts of information and the wide variety of tasks to be performed. An important consideration in building tool environments for reengineering is what information must be provided and how this information is modelled. Design choices have a consider- able impact not only on the ability to support reengineering tasks, but also on issues such as scalability and tool interoperability. Several metamodels exist that model software for the purposes of reengineering. How- ever, they generally lack a discussion of the relevance of information for reengineering and the trade-offs of modeling alternatives. This thesis presents FAMIX, a language-independent metamodel for modelling object-oriented soft- ware for reengineering purposes. We discuss the exact contents of the metamodel, including its relevance for reengineering and how the metamodel supports the different object-oriented languages through its lan- guage-independent core. We also discuss the infrastructural design decisions of FAMIX by placing it into a design space for infrastructural aspects of reengineering repositories and metamodels. The design space presents multiple interdependent aspects, their design alternatives and how these impact issues such as scal- ability, extensibility and information exchange. We validate the ability of FAMIX to support reengineering on a language-independent level in two ways. First, we present Moose, a reengineering tool environment with a repository based on FAMIX. Moose serves as a foundation for multiple reengineering tools and has been applied to reverse engineer several large industrial case studies. Secondly, we define a set of fifteen low-level refactorings in terms of the infor- mation available in FAMIX. Refactoring requires sufficient, complete and 100% correct information as well as a clear interpretation of the supported languages in the language-independent core of the metamod- el, in order to correctly perform transformations on the language-specific code level. As such the refactor- ings provide an in-depth validation of the language independence of FAMIX.

ions through Manipulation of a Program Visualization A dissertation submitted in partial satisfaction of the requirements for the degree Doctor of Philosophy in Computer Science by Robert William Bowdidge Committee in charge: Professor William G. Griswold, Chair Professor Edwin Hutchins Professor Keith Marzullo Professor Joseph Pasquale Professor Richard N. Taylor Copyright Robert William Bowdidge, 1995 All rights reserved. The dissertation of Robert William Bowdidge is approved, and it is acceptable in quality and form for publication on microfilm: Chair University of California, San Diego 1995 iii For Christine iv TABLE OF CONTENTS Signature Page : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : iii Dedication : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : iv Table of Contents : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : v List of Figures : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : ix List of Tabl...

Restructuring software to improve its design can lower software maintenance costs. One problem in restructuring is planning out the redesign. The star diagram manipulable visualization can help a programmer redesign a program based on abstract data types. However, the underlying meaning-preserving transformational support for restructuring is costly to provide.

In this paper, we show how elaborate support for framework-based software evolution can be provided based on explicit documentation of the hot spots of object-oriented application frameworks. Such support includes high-level transformations that guide a developer when instantiating applications from a framework by propagating the necessary changes, as well as application upgrading facilities based on these transformations. The approach relies on active declarative documentation of the design and evolution of the framework's hot spots, by means of metapatterns and their associated transformations.

Software development can be characterized in terms of prototype (or initial design) phases, expansion phases and consolidation phases. During a consolidation phase, some relationships, initially modeled using inheritance, may beevolved to aggregations. Also, during consolidation, abstrasct classes are sometimes defined to capture behavior common to two or more existing classes. In this paper, we de ne high-level patterns for the prototype, expansion and consolidating programs. We also define supporting patterns for evolving aggregations from inheritance hierarchies and for creating abstract classes.

My PhD thesis [7] claims that the principles behind object-oriented software evolution are independent of a particular domain or phase in the software lifecycle. To validate this claim, a formalism based on graphs and graph rewriting was developed and applied to a particular aspect of software evolution, namely the problem of software upgrading and software merging. When the same piece of software is modified in parallel by different software developers, unexpected inconsistencies can arise. Formal support can be provided to detect and resolve these inconsistencies in a general way.

Software libraries provide leverage in large part because they are used by many applications. As Parnas, Lampson and others have noted, stable interfaces to libraries isolate the application from changes in the libraries. That is, as long as there is no change in a library's syntax or semantics, applications can use updated libraries simply by importing and linking the new version. However, libraries are indeed changed from time to time and the tedious work of adapting the application source to the library interface changes becomes a burden to multitudes of programmers. This paper introduces an approach and a toolset intended to reduce these costs. Specifically, in our approach a library maintainer annotates changed functions with rules that are used to generate tools that will update the applications that use the updated libraries. Thus, in exchange for a small added amount of work by the library maintainers, costs to each application maintainer can be reduced. We present the basic ap...

Software is difficult and costly to modify correctly. Automating tiresome mechanical tasks such as program restructuring is one approach to reducing the burden of software maintenance. Several restructuring tools have been proposed and prototyped, all centered on the concept of meaning-preserving transformations similar in spirit to compiler optimizations. Like optimizing compilers, these tools rely on static analysis to reason about the correctness of program changes. However, the cost (in both time and space) of static analysis serves as the limiting factor for transformation tools, resulting in slow, complex tool designs that scale poorly for use on large systems. To reduce these costs, this thesis proposes efficient, demand-driven flow analysis techniques as an alternate to traditional, compiler-based methods. These techniques operate directly on the abstract syntax tree (AST), the data structure most appropriate for use in a source-to-source tool architecture. By eliminating the need for other program representations such as the standard control flow graph (CFG) or program dependence graph (PDG), this approach greatly simplifies program modification. A key contribution of this work is the idea of virtual control flow, a method for computing the control successors or predecessors of individual AST expressions on demand. This method handles all types of structured and unstructured jumps found in an imperative programming language such as C. Virtual control flow couples well with demand-driven data flow analysis to minimize the cost of determining semantic information. To conservatively estimate data flow relationships, the effects of aliasing between memory locations can be inexpensively approximated using flow-insensitive points-to analysis based on type inference. These techniques were implemented in a prototype tool called Cstructure to support a simple restructuring transformation for reordering program statements. To check that this transformation does not change the program's behavior requires syntax, control flow and data dependence analysis. Experimental results on three programs ranging in size from 72,000 to 213,000 lines of code demonstrate the performance advantages of such aggressive demand-driven approaches. For the largest program, gcc, check times for the average statement were 50 milliseconds on a desktop workstation.