Schema Evolution publication categorizer

Large, mission critical applications built on Oracle Database 11g Release 1 and earlier
versions are often unavailable for tens of hours while the application’s database objects
are patched or upgraded. Oracle Database 11g Release 2 introduces edition-based
redefinition, a revolutionary new capability that allows online application upgrade with
uninterrupted availability of the application. When the installation of the upgrade is
complete, the pre-upgrade application and the post-upgrade application can be used at

We propose static program analysis techniques for identifying the impact of relational database schema changes upon object-oriented applications. We use dataflow analysis to extract all possible database interactions that an application may make. We then use this information to predict the effects of schema change. We evaluate our approach with a case-study of a commercially available content management system, where we investigated 62 versions of between 70k-127k LoC and a schema size of up to 101 tables and 568 stored procedures.

The old problem of managing the history of database information is now made more urgent and complex by fast-spreading web information systems. Indeed, systems such as Wikipedia are faced with the challenge of managing the history of their databases in the face of intense database schema evolution. Our PRIMA system addresses this difficult problem by introducing two key pieces of new technology.

The escalating complexity of software and system models is making it difficult to
rapidly explore the effects of a design decision.Automating such exploration with
model transformation and aspect-oriented techniques can improve both productivity
and model quality.

Model differentiation techniques, which provide the capability to identify mappings and
differences between models, are essential to many model development and management
practices. There has been initial research toward model differentiation applied to UML diagrams,
but differentiation of domain-specific models has not been explored deeply in the modeling
community. Traditional modeling practice using the UML relies on a single fixed generalpurpose
language (i.e., all UML diagrams conform to a single metamodel). In contrast, Domain-

Database reengineering consists of deriving a new database from a legacy database and adapting the software components accordingly. This migration process involves three main steps, namely schema conversion, data conversion and program conversion. This paper explores the feasibility of transforming the application programs through code transformation patterns that are automatically derived from the database transformations. It presents the principles of a new transformational approach coupling database and program transformations and it describes a prototype CASE tool based on this approach.

After more than 20 years of research and practice in software configuration management (SCM), constructing consistent configurations of versioned software products still remains a challenge. This article focuses on the version models underlying both commercial systems and research prototypes. It provides an overview and classification of different versioning paradigms and defines and relates fundamental concepts such as revisions, variants, configurations, and changes. In particular, we focus on intensional versioning, that is, construction of versions based on configuration rules.

In this paper we present a proposal for safely evolving a software sys-
tem against run-time changes. This proposal is based on a reflective architecture
which provides objects with the ability of dynamically changing their behavior
by using their design information. The meta-level system of the proposed archi-
tecture supervises the evolution of the software system to be adapted that runs
as the base-level system of the reflective architecture. The meta-level system is
composed of cooperating components; these components carry out the evolution

The term rule-based program is meant to include definite clause programs, SOS specifications, attribute grammars, and conditional rewrite systems. These setups are widely used for the executable specification or implementation of language-based tools, e.g., interpreters, translators, type checkers, program analysers, and program transformations.

We provide an extensive overview of existing research in the field of software refactoring. This research is compared and discussed based on a number of different criteria: the refactoring activities that are supported, the specific techniques and formalisms that are used for supporting these activities, the types of software artifacts that are being refactored, the important issues that need to be taken into account when building refactoring tool support, and the effect of refactoring on the software process. A running example is used to explain and illustrate the main concepts.

Previous taxonomies of software evolution have focused on the purpose of the change (i.e., the why)
rather than the underlying mechanisms. This paper proposes a taxonomy of software evolution based
on the characterizing mechanisms of change and the factors that influence these mechanisms. The
taxonomy is organized into the following logical groupings: temporal properties, objects of change,
system properties, and change support.
The ultimate goal of this taxonomy is to provide a framework that positions concrete tools, formalisms

In the context of object-oriented design, software systems model real-world entities abstractly represented in the system classes. As the system evolves through its lifecycle, its class design also evolves. Thus, understanding class evolution is essential in understanding the current design of the system and the rationale behind its evolution. In this paper, we describe a taxonomy of class-evolution profiles, a method for automatically categorizing a system's classes in one (or more) of eight types in the taxonomy, and a data-mining method for eliciting co-evolution relations among them.

Dynamic change is a large and pervasive unsolved problem which surfaces within office systems as well as within software engineering, manufacturing, and numerous other domains. Procedural changes, performed in an ad hoc manner, can cause inefficiencies, inconsistencies, and catastrophic breakdowns within offices. This paper is concerned with dynamic change to procedures in the context of workflow systems. How can we make workflow systems more flexible and open?

Experience shows that even after programs have been designed, built and tested, change
is more the norm than the exception. Consider a shared object-oriented persistent system
built to serve the business needs of a company. Changes such as additions of classes or
class members, renamings, retypings, etc. may be needed to introduce new applications,
enhance existing ones, or integrate separately built systems. Additional changes such as
factoring out duplicate code, rearranging the class hierarchy and delegating responsibilities

The past two decades have seen increasing sophistication in software work. Now and in the future, the work of both practitioners and researchers would be helped by a more objective and finer granularity recognition of types of software evolution and software maintenance activities as actually done. To these ends, this paper proposes a clarifying redefinition of the types of software evolution and software maintenance.

The authors review propagation patterns for describing object-oriented software at a higher level of abstraction than one used by today's programming languages. A propagation pattern defines a family of programs from which one can select a member by giving a class dictionary graph that details the structure of behavior through part-of and inheritance relationships between classes. Three concepts are introduced: evolution histories, growth-plans and a propagation-directive calculus.