Vincent Englebert

Database Design Recovery

The design of a software component, such as a database, is the trace of all the processes, products and reasonings that have led to the production of this artifact. Such a document is the very basis of system maintenance and evolution processes. Unfortunately, it does not exist in most situations. The paper describes how the design of a database or of a collection of files can be recovered through reverse engineering techniques. Recording the reverse engineering activities provides a history of this process. By normalizing and reversing this history, then by conforming it according to a reference design methodology, one can obtain a tentative design of the source database. The paper describes the baselines of the approach, such as a wide spectrum specification model, semantics-preserving transformational techniques, and a design process model. It describes a general procedure to build a possible DB design, then states the requirements for CASE support, and describes DB-MAIN, a prototype CASE tool which includes a history processor. Finally it illustrates the proposals through an example.

Program Understanding in Databases Reverse Engineering

The main argument of the paper is that database understanding (or reverse engineering) requires sophisticated program understanding techniques, and conversely. Database reverse engineering (DBRE) can be carried out following a generic methodology, one of the phases of which consists in eliciting all the implicit and untranslated data structures and constraints. Evidences of these hidden constructs can be found by analysing how the programs use and update the data. Hence the need for program analysis techniques such as searching for cliches, dependency analysis, program slicing and synthetic views. The paper explains how these techniques contribute to DBRE, and describes DB-MAIN, a programmable and extensible CASE environment that supports DBRE through program understanding techniques.

Database reverse engineering: from requirements to CARE tools

This paper analyzes the requirements that CASE tools should meet for effective database reverse engineering (DBRE), and proposes a general architecture for data-centered applications reverse engineering CASE environments. First, the paper describes a generic DBMS-independent DBRE methodology, then it analyzes the main characteristics of DBRE activities in order to collect a set of desirable requirements. Finally, it describes DB-MAIN, an operational CASE tool developed according to these requirements. The main features of this tool that are described in this paper are its unique generic specification model, its repository, its transformation toolkit, its user interface, the text processors, the assistants, the methodological control and its functional extensibility. Finally, the paper describes five real-world projects in which the methodology and the CASE tool were applied.

Requirements for information system reverse engineering support

This paper proposes a general architecture for information systems (or data-centered applications) reverse engineering CASE environments. Recovering the specifications of such applications requires recovering first those of their data, i.e. database reverse engineering (DBRE). First, the paper describes a generic DMS-independent DBRE methodology, then it analyses the main characteristics of DBRE activities in order to collect a set of minimum or desired requirements. Finally, it describes the main features of an operational CASE tool developed according to these requirements. This study and these developments are being carried out as part of the DB-MAIN and DB-PROCESS projects.

Structure elicitation in database reverse engineering

Recovering the semantic description of file and database structures is an important aspect of business application reverse engineering. It includes a particularly delicate activity, namely data structure extraction, i.e. finding the exact data structures and integrity constraints of the database. This process is made more complex than generally expected due to the fact that these structures and constraints often are not explicitly defined, but are translated into implicit constructs, controlled and managed through procedural code or user interface protocol for instance. This paper describes the problem of implicit structure elicitation. It proposes an analysis of this phenomenon, and of the techniques and heuristics that can be used in the elicitation. It develops a set of efficient techniques and a for the elicitation of one of the most common implicit construct, namely the foreign key. The paper also explains how DB-MAIN, a general-purpose database reverse engineering CASE tool, can help analysts elicit implicit constructs, and specifically foreign keys.

Generic abstract interpretation algorithms for Prolog: two optimization techniques and their experimental evaluation

The efficient implementation of generic abstract interpretation algorithms for Prolog is reconsidered after References 1 and 2. Two new optimization techniques are proposed and applied to the original algorithm of Reference 1: dependency on clause prefixes and caching of operations. The first improvement avoids re‐evaluating a clause prefix when no abstract value which it depends on has been updated. The second improvement consists of caching all operations on substitutions and reusing the results whenever possible. The algorithm and the two optimization techniques have been implemented in C (about 8000 lines of code each), tested on a large number of Prolog programs, and compared with the original implementation on an abstract domain containing modes, types and sharing. In conjunction with refinements of the domain algorithms, they produce an average reduction of more than 58 per cent is computation time. Extensive experimental results on the programs are given, including computation times, memory consumption, hit ratios for the caches, the number of operations performed, and the time distribution. As a main result, the improved algorithms exhibit the same efficiency as the specific tools of References 3 and 4, despite the fact that our abstract domain is more sophisticated and accurate. The abstract operations also take 90 per cent of the computation time, indicating that the overhead of the control is very limited. Results on a simpler domain are also given and show that even extremely basic domains can benefit from the optimizations. The general‐purpose character of the optimizations is also discussed.

DB-main: a next generation meta-case

Abstract This paper describes the DB-MAIN meta-CASE architecture that attempts to conciliate seemingly contradictory goals concerning efficiency, ergonomics, evolution, reuse and ontologies integration. The architecture is based on two layers, the first of which includes built-in basic concepts and functions that should be part of every Information System oriented CASE tool. The second layer comprises four meta-mechanisms intended to reuse, extend and specialize the basic constructs: ontology definition (through a dynamic repository), graphical interface definition, functional definition and methodology definition. These mechanisms are activated through four cooperating languages that allows the CASE engineer to customize the DB-MAIN environment from merely adapting the graphical interface to defining new modeling domains. The paper shows how these mechanisms meet a hierarchy of requirements and how they compare with the current state of the art.

Knowledge transfer in database reverse engineering: a supporting case study

While the database reverse engineering problems and solving processes are getting more and more mastered, the academic community is facing the complex problem of knowledge transfer, both in university and industrial contexts. The paper addresses one efficient support of this transfer, namely academic case studies, i.e., small, clean, self-contained applications exhibiting representative problems and appropriate solutions that can be mastered in a limited time. First it recalls the basics of a generic methodology for database reverse engineering comprising two main steps, namely data structure extraction and data structure conceptualization. Then it describes a small academic case study, which has been used for several years both as an illustration of the principles of DBRE and as an exercise aimed at academic and industrial students.

Understanding Implementations of IS-A Relations

Generalization/specialization hierarchies (IS-A relations for short) are basic semantic constructs proposed in most information system conceptual models. At the other side of design methodologies, where standard DBMSs are used, and will still be used for several years, there is no explicit representation of these IS-A relations. As a consequence, all the current methodologies include rules through which these semantic constructs are transformed into standard structures. However, it quickly appears that the translation rules proposed are most often incomplete, and sometimes incorrect. This fact has been experienced by many practitioners, who are faced with complex translation problems, but who do not find satisfying help neither in modern text books, nor in CASE tools. The aim of this paper is to analyze IS-A relations in some detail, and to propose a wide range of correct techniques to express IS-A relations into standard constructs. Understanding these techniques has also proved essential in reverse engineering processes.

Towards more extensible metaCASE tools

In this paper, we suggest a solution to several limitations of current metaCASE technology: (i) the limited number of modelling levels, (ii) the rigid separation between those levels, (iii) the limited bootstrapping possibilities, (iv) the hardcoding of various types of information (e.g. GUI related information), and (v) the inability to record links between semantically related (e.g. referrentially redundant) constructs. Our proposal is centered around a 2-layer metamodelling language called MetaL. MetaL is characterised by ubiquitous reflexivity (metacircularity) and extended reification capabilities. The language is presented and applied to illustrative examples. Its pros and cons are discussed and an on-going prototypical metaCASE implementation is reported.