Skip to main content
Engineering LibreTexts

1.2: The Reengineering Lifecycle

  • Page ID
  • Reengineering and reverse engineering are often mentioned in the same context, and the terms are sometimes confused, so it is worthwhile to be clear about what we mean by them. Chikofsky and Cross [CI92] define the two terms as follows:

    Reverse Engineering is the process of analyzing a subject system to identify the system’s components and their interrelationships and create representations of the system in another form or at a higher level of abstraction.”

    That is to say, reverse engineering is essentially concerned with trying to understand a system and how it ticks.

    Reengineering ... is the examination and alteration of a subject system to reconstitute it in a new form and the subsequent implementation of the new form.”

    Reengineering, on the other hand, is concerned with restructuring a system, generally to fix some real or perceived problems, but more specifically in preparation for further development and extension.

    The introduction of term “reverse engineering” was clearly an invitation to define “forward engineering”, so we have the following as well:

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

    How exactly this process of forward engineering can or should work is of course a matter of great debate, though most people accept that the process is iterative, and conforms to Barry Boehm’s so-called spiral model of software development [Boe88]. In this model, successive versions of a software system are developed by repeatedly collecting requirements, assessing risks, engineering the new version, and evaluating the results. This general framework can accommodate many different kinds of more specific process models that are used in practice.

    If forward engineering is about moving from high-level views of requirements and models towards concrete realizations, then reverse engineering is about going backwards from some concrete realization to more abstract models, and reengineering is about transforming concrete implementations to other concrete implementations.

    Forward, reverse and reengineering.
    Figure \(\PageIndex{1}\): Forward, reverse and reengineering.

    Figure \(\PageIndex{1}\) illustrates this idea. Forward engineering can be understood as being a process that moves from high-level and abstract models and artifacts to increasing concrete ones. Reverse engineering reconstructs higher-level models and artifacts from code. Reengineering is a process that transforms one low-level representation to another, while recreating the higher-level artifacts along the way.

    The key point to observe is that reengineering is not simply a matter of transforming source code, but of transforming a system at all its levels. For this reason it makes sense to talk about reverse engineering and reengineering in the same breath. In a typical legacy system, you will find that not only the source code, but all the documentation and specifications are out of sync. Reverse engineering is therefore a prerequisite to reengineering since you cannot transform what you do not understand.

    Reverse engineering

    You carry out reverse engineering whenever you are trying to understand how something really works. Normally you only need to reverse engineer a piece of software if you want to fix, extend or replace it. (Sometimes you need to reverse engineer software just in order to understand how to use it. This may also be a sign that some reengineering is called for.) As a consequence, reverse engineering efforts typically focus on redocumenting software and identifying potential problems, in preparation for reengineering.

    You can make use of a lot of different sources of information while reverse engineering. For example, you can:

    • read the existing documentation

    • read the source code

    • run the software

    • interview users and developers

    • code and execute test cases

    • generate and analyze traces

    • use various tools to generate high-level views of the source code and the traces

    • analyze the version history

    As you carry out these activities, you will be building progressively refined models of the software, keeping track of various questions and answers, and cleaning up the technical documentation. You will also be keeping an eye out for problems to fix.


    Although the reasons for reengineering a system may vary, the actual technical problems are typically very similar. There is usually a mix of coarse-grained, architectural problems, and fine-grained, design problems. Typical coarse-grained problems include:

    • Insufficient documentation: documentation either does not exist, or is inconsistent with reality.

    • Improper layering: missing or improper layering hampers portability and adaptability.

    • Lack of modularity: strong coupling between modules hampers evolution.

    • Duplicated code: “copy, paste and edit” is quick and easy, but leads to maintenance nightmares.

    • Duplicated functionality: similar functionality is reimplemented by separate teams, leading to code bloat.

    The most common fine-grain problems occurring in object-oriented software include:

    • Misuse of inheritance: for composition, code reuse rather than polymorphism

    • Missing inheritance: duplicated code, and case statements to select behavior

    • Misplaced operations: unexploited cohesion — operations outside in- stead of inside classes

    • Violation of encapsulation: explicit type-casting, C++ “friends” .

    • Class abuse: lack of cohesion — classes as namespaces

    Finally, you will be preparing the code base for the reengineering activity by developing exhaustive test cases for all the parts of the system that you plan to change or replace.

    Reengineering similarly entails a number of interrelated activities. Of course, one of the most important is to evaluate which parts of the system should be repaired and which should be replaced.

    The actual code transformations that are performed fall into a number of categories. According to Chikofsky and Cross:

    Restructuring is the transformation from one representation form to another at the same relative abstraction level, while preserving the system’s external behavior.”

    Restructuring generally refers to source code translation (such as the automatic conversion from unstructured “spaghetti” code to structured, or “goto-less”, code), but it may also entail transformations at the design level.

    Refactoring is restructuring within an object-oriented context. Martin Fowler [FBB+99] defines it this way:

    Refactoring is the process of changing a software system in such a way that it does not alter the external behavior of the code yet improves its internal structure.”

    It may be hard to tell the difference between software “reengineering” and software “maintenance”. IEEE has made several attempts to define software maintenance, including this one:

    “the modification of a software product after delivery to correct faults, to improve performance or other attributes, or to adapt the product to a changed environment”

    Most people would probably consider that “maintenance” is routine whereas “reengineering” is a drastic, major effort to recast a system, as suggested by Figure \(\PageIndex{1}\).

    Others, however, might argue that reengineering is just a way of life. You develop a little, reengineer a little, develop a little more, and so on [Bec00]. In fact, there is good evidence to support the notion that a culture of continuous reengineering is necessary to obtain healthy, maintainable software systems.

    Continuous reengineering, however, is not yet common practice, and for this reason we present the patterns in this book in the context of a major reengineering effort. Nevertheless, the reader should keep in mind that most of the techniques we present will apply just as well when you reengineer in small iterations.