5.2 The Context for Program Understanding: The Horseshoe Model


5.2 The Context for Program Understanding: The Horseshoe Model

A system modernization effort evolves an existing legacy system in a disciplined way. This effort consists of three basic processes:

  1. Reconstructing one or more higher-level, logical descriptions of the system from existing artifacts

  2. Transforming the logical descriptions into new, improved logical descriptions

  3. Refining these new and improved logical descriptions to source-level code

The degree to which each of these processes is applied depends on the goals of the modernization effort. For example, a complete architectural transformation requires reconstructing the existing architecture, whereas a retargeting effort requires understanding only the code structure. Figure 5-1 illustrates a conceptual "horseshoe" that reconciles reengineering and architectural views of software analysis and evolution [Carriere 99, Woods 99, Kazman 98].

Figure 5-1. The horseshoe model

graphics/05fig01.gif

The three basic modernization processes ”reconstruction, transformation, and refinement ”form the basis of the horseshoe. Reconstruction goes up the left of the horseshoe, transformation goes across the top, and refinement goes down the right. The horseshoe model identifies three levels of abstraction that can be used for the logical descriptions, which can be as concrete and simple as the source code of the system or as abstract and complex as the system architecture. Taken as a whole, the visual metaphor integrates both the code-level and the architectural reengineering views of the world.

For example, the trip around the outside of the horseshoe represents a complete architectural transformation. However, code and functional transformations are also possible, depending on the goal of the modernization effort. These transformations are represented by two additional levels cross-cutting the horseshoe. In these cases, the reconstruction process does not result in a system architecture representation but rather in lower-level artifacts that may be closer to the source code. These paths across the horseshoe represent pragmatic choices based on the organizational or technological constraints, including the availability of reengineering tools. The three levels of abstraction and transformation are described in greater detail in the following sections.

Code Transformations

Code transformations are quick-and-dirty forms of software evolution, including such techniques as retargeting or source code translation. They are often associated more with maintenance activities than with reengineering activities. If the software is old and poorly structured and if none of the original designers is around to explain the structure of the code, this may be the best way to evolve the system. Code transformation does little to improve the structure of the legacy code and often results in code that is even more difficult to maintain. Retargeting is an important element of the RSS modernization effort. The specific use of retargeting in the case study is described in Section 14.2.

Functional Transformations

Functional-level transformations are a medium-level approach to code transformations. These transformations are often associated with efforts to change technology while maintaining basic functionality. Functional transformations are often required, for example, when changing from a functional to an object-oriented paradigm, from client/server to object request broker, from off-line processing to electronic commerce, or from a hierarchical to a relational database. These changes tend to be concentrated in the system interfaces but may also be far reaching.

To make functional-level transformations, the structure of the system must be understood ”at least at the interface level. When the internals are not well understood , it may be possible to wrap modules of functionality for use in another context.

Functional-level transformations can provide major benefits over code-level transformations. Mined and rehabilitated assets become better structured and provide clearly defined and better-documented interfaces.

Architectural Transformations

The highest abstraction level in the horseshoe represents architectural transformation. In this case, the reconstruction process results in complete architectural recovery. Once this process is completed, it is possible to determine whether the as-built architecture conforms to the as-designed architecture ”if it is available ”and identify deviations. The discovered architecture can be analyzed with respect to performance, modifiability, security, reliability, or other quality attributes.

In the transformation process, the as-built recovered architecture is reengineered and then reevaluated against the system's quality goals. The refinement process transforms the architecture into a design and refines the design into source code.

The refinement process can be the same one used to develop custom code but may need to support the integration of existing code-level artifacts from the legacy system. This refinement process closely resembles processes for building systems from off-the-shelf components , such as the ones described in Building Systems from Commercial Components [Wallnau 01]. Specifically, the artifacts in the replacement system must be identified and their function in the new system clearly defined. Wrapping and interconnection strategies for integrating the legacy component must then be identified. However, unlike building systems from commercial components, the legacy system components may be modified to make them better fit for use in the new system.



Modernizing Legacy Systems
Modernizing Legacy Systems: Software Technologies, Engineering Processes, and Business Practices
ISBN: 0321118847
EAN: 2147483647
Year: 2003
Pages: 142

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net