This section describes the terminology used throughout the bibliography. The terminology was defined by Chikofsky and Cross [Chikofsky:90a] and Byrne [Byrne:92].

The list is in alphabetical order.

Design recovery

is a subset of reverse engineering in which domain knowledge, external information, and deduction or fuzzy reasoning are added to the observations of the subject system to identify meaningful higher level abstractions beyond those obtained directly by examining the system itself. Design recovery recreates design abstractions from a combination of code, existing design documentation (if available), personal experience, and general knowledge about problem and application domains.

Forward engineering

is the traditional process of moving from high-level abstractions and logical, implementation-independent designs to the physical implementation of a system.

Program understanding

is a related term to reverse engineering. Program understanding implies always that understanding begins with the source code while reverse engineering can start at a binary and executable form of the system or at high level descriptions of the design. The science of program understanding includes the cognitive science of human mental processes in program understanding. Program understanding can be achieved in an ad hoc manner and no external representation has to arise. While reverse engineering is the systematic approach to develop an external representation of the subject system. Program understanding is comparable with design recovery cause both of them start at source code level.

Reclamation

is a synonym to reengineering.

Re-code

is a change to implementation characteristics. Language translation and control-flow restructuring are source code level changes. Other possible changes include conforming to coding standards, improving source code readability, renaming program items, etc.

Re-design

is a change to design characteristics. Possible changes include restructuring a design architecture, altering a systems's data model as incorporated in data structures, or in a database, improvements to an algorithm, etc.

Redocumentation

is the creation or revision of a semantically equivalent representation within the same relative abstraction level. The resulting forms of representation are usually considered alternate views (for example, dataflow, data structures, and control flow) intended for a human audience. Redocumentation is the simplest and oldest form of reverse engineering, and can be considered to be an unintrusive, weak form of restructuring.

Reengineering

(also known as renovation and reclamation) is the examiniation and alteration of a subject system to reconstitute it in a new form and the subsequent implementation of the new form.

Reformatting

is the functionally equivalent transformation of source code which changes only the structure to improve readability. Examples are pretty printers.

Renovation

a synonym to reengineering.

Re-specify

is a change to requirements characteristics. This type of change can refer to changing only the form of existing requirements. For example, taking informal requirements expressed in English and generating a formal specification expressed in a formal language such as Z. This type of change can also refer to changing system requirements. Requirement changes include the addition of new requirements, or the deletion or alteration of existing requirements.

Restructuring

is the transformation from one representation form to another at the same relative abstraction level, while preserving the subject's system external behavior (functionality and semantics).

Reverse design

is a synonym to design recovery.

Reverse engineering

is the process of analyzing a subject system to (i) identify the system's components and their interrelationships and (ii) create representations of the system in another form or a higher level of abstraction.

Reverse specification

is a kind of reverse engineering where a specification is abstracted from the source code or design description. Specification in this context means an abstract description of what the software does . In forward engineering, the specification tells us what the software has to do. But this information is not included in the source code. Only in rare cases, it can be recovered from comments in the source code and from the people involved in the original forward engineering process.