Figure 2: Hybrid Re-Engineering Tracks
Figure 2: Hybrid Re-Engineering Tracks
Figure 2: Hybrid Re-Engineering Tracks
In Figure 2, three development tracks are utilized. The first track is a translation
from existing code to a new language, operating system or hardware platform with no
abstraction. The second track uses the existing code to identify requirements that can be
satisfied by the application of COTS packages. The third track is the development of
custom code for project unique requirements that cannot be satisfied by either other
track, and to “glue” together the other components. Re-engineering as a development
methodology has inherent risks such as schedule, functionality, cost, and quality.
Hybrid re-engineering was developed to decrease some of these risks since COTS
packages are expected to have high reliability and require minimal development time.
Hybrid re-engineering is innovative, combining three distinct re-engineering efforts;
hence the risks generally associated with re-engineering can increase by combining the
risks inherent to each track. Since hybrid reengineering is combining products from
different development tracks (COTS, custom software and translated software), one
new risk is the interface and interoperability of the products. For example, data transfer
between products can cause compatibility and timing problems; COTS packages may
not work exactly as anticipated.
The following sections describe each of the three hybrid re-engineering tracks. After
each track is described, the risks associated with the track are identified and appropriate
metrics defined.
Figure 3 is a diagram of a “typical” software system that has been in use for some
period of time. In this reengineering example, we assume the project is moving from
FORTRAN to C++ (but not necessarily to an object-oriented design). In looking at the
current software system, the manager sees two classifications of code, some stable code
that has had minimal modifications and whose requirements have remained stable, and
some code that has under gone multiple changes and has become unstable, unreliable,
and costly to maintain. Re-engineering the stable code may not require total reverse
engineering; it might be feasible to simply re-code this portion into the new language or
new environment. This process constitutes the translation track of hybrid re-
engineering.
In this track, shown in Figure 4, the code in the existing system that is relatively
stable, having had minimal changes to the original design and architecture must be
identified. This can be accomplished by an analysis of the code and of change reports.
Many source code translators are available to support the transport of code from one
language or operating system to another. An advantage of simply translating code is that
maintenance personnel will still understand the program flow since it remains
unchanged. This will aid them in becoming effective in the new language. Source code
translators may not be adequate alone since line-byline translators don’t take advantage
of target language semantics, constructs, etc., often resulting in code know as “C-
TRAN” - C syntax on FORTRAN structures. In the Translation track, the primary risk
is the quality of the resulting code. When transitioning from one language to another,
the code can have the syntax of the new language but none of the structures or new
features. While the initial legacy code was of adequate quality, this does not guarantee
that the resulting code will have the same quality. If the quality is not adequate,
code may have to be improved. If 20 - 30% of the translated code must be changed to
improve its quality or to meet standards, the code should not be used and those
functions or components should be re-engineered using another of the three tracks.
Once the re-engineering is complete, it is important to verify that the functionality is
retained in the new system, as well as the quality of the code has improved, hence
implying improved maintainability.
Although the use of COTS software decreases the development time and increases
the reliability, COTS also introduce additional risks. A major risk is that the package
will not perform as anticipated or advertised, that it is unreliable, immature or
incomplete. The package may also undergo frequent manufacturer version
enhancements requiring constant upgrading. In the worse case, changes may alter or
remove functions needed for the system. The COTS may require modifications or
supplementation to match the requirements, causing increases in schedule and
decreasing reliability. In addition, the use of a COTS may limit further enhancements to
the system, since changes in the COTS provided functions may not be possible due to
legal issues. The stability of the vendor should also be part of the evaluation process
since it may be necessary for them to make later required changes. An additional cost
may be incurred due to the unfamiliarity with the COTS. Simple changes to usability,
such as new icons, will require additional training time Some metrics are applicable to
assist in decreasing the risks associated with the selection of COTS packages,. It is
important to first identify what percentage of the desired requirements the package
totally meets, and which requirements the package partially meets. This information can
then be used to determine how much rework or supplementation the package requires in
order to totally fulfill the system requirements. Modification or supplementation will
impact the schedule and budget, and may well impact maintainability and reliability.
After all of these evaluations are complete, the cost to develop from scratch should also
be estimated, including testing time, and compared to the total costs of the COTS.
In this track, once the COTS have been implemented, the functionality of the existing
system must be compared to the functionality of the target system. The process of
comparison must be based on testing, as was done for translated code function
The disadvantages are similar to standard software development, in that the code
might not be reliable requiring additional testing, and that the development/testing
process may exceed time and cost budgets. Custom code has the same inherent risks
that any code has, to quality, reliability, and schedule. Since most of the functions of the
legacy system identified as unique to the system will be done with custom code, the risk
is that one of the unique features will not be identified and hence the functionality of the
new system will be incomplete. Features identified as critical to the system that are
accomplished with custom code will require extensive testing. Metrics for this track are
a combination of both process and product metrics. Prior to reverse engineering, the
quality of the existing system should be evaluated for later comparison to the target
system (as discussed previously). Effort expended should be tracked to assist in the
evaluation of the cost to re-engineer. This can also be used to approximate schedule
completion using the estimate that 60% of the time is in reverse engineering. Once
requirements are re-specified, their quality can be evaluated to determine testability.
Also discussed previously was the use of function points as a means of calculating the
rate of functionality transfer to the target system. Code analysis tools can be used to
evaluate the quality of the code as it is being developed and identify the risks. In testing,
discrepancy or error rates help in evaluating reliability. In this track, both the
functionality and the quality are compared between the existing system and the target
system.
a guideline in identifying optimal strategies (translation, COTS, etc.), and projecting the
cost of the target system. Once the decision on using a hybrid reengineering approach is
made, additional analysis is needed. The first step in a hybrid re-engineering approach is
to investigate the requirements and constraints of the development. These factors
include setting a time table for reverse and forward engineering. Time must be built in
to investigate available COTS, including hands on testing of the COTS. While forward
engineering development time should decrease with the use of COTS and the translation
of code, additional time will be needed for testing the integration and interface of the
products of the three tracks. Budget constraints must also be considered; how much can
be spent on COTS that provide required features versus those that provide desired
features. Management mandated and organization needs must also be identified. As the
three tracks are developed, tradeoffs will be necessary so it is important to prioritize
requirements The next step is to do an in-depth analysis of the legacy system, focusing
on functionalities and code segments suitable for each of the three tracks (Translation,
Custom, COTS). In generic re-engineering, an analysis of the existing system is usually
done to provide an evaluation of the quality of the existing system and maintenance
costs. This information is used to justify the costs and improvements at the conclusion
of the re-engineering effort. While these reasons are still relevant in hybrid
reengineering, additional features of the legacy system must now be investigated.
During the assessment of the legacy system, sections and functionalities must be
identified. These must be further assessed to determine what documentation is available
to identify the required features versus what is no longer needed or what users have
become accustomed to. Code sections must be ordered by the cost of maintenance, and
the quality of the current structure. Functions that are unique to this project must be
identified. All of these components will be used to identify which hybrid re-engineering
track will be applied to the code section. Once the code has been divided into the
development tracks, each track will proceed independently as discussed. The schedule
for track completion will differ based on tasks. As the tracks conclude various tasks, the
merging of the final products can begin. For example, the custom glue can be started
once the COTS have been selected. Training on these packages can also begin. Once the
system is complete and all tracks merged, two tasks remain: testing and justification.
All software development has inherent risks to schedule and cost. Hybrid re-
engineering, as a software development methodology, is also susceptible to them.
Hybrid re-engineering, because of its composition of the three diverse development
tracks, is subject to all of the risks that were discussed within each track description.
Also, Hybrid re-engineering as a unique software reengineering methodology has
additional risks to functionality and quality; the functionality of the existing system
must be preserved in the new system, and the quality must improve, implying a
decrease in operational and maintenance costs. With all of the risks in Hybrid
reengineering, why bother, why not just treat it as a new software development effort
and omit the re-engineering all together? Because of the benefits.
Metrics, when properly applied, provide managers information about their project
to help mitigate risks.[5] It is logical therefore, to discuss some of the re-engineering
phases where metrics provide valuable information. Previously we have identified
metrics applicable for each track in hybrid re-engineering. In this section, we will
discuss metrics applicable to the entire project, not just one track. Metrics provide
information on the quality, functionality, and on track selection, a prime areas of risk.
At the start of the re-engineering effort, the legacy system must be quantified. There are
two objectives: identify the amount of functionality and the quality of the existing
system. By quantifying the functionality, scheduling estimates are more accurate;
during development, completion can be estimated by the percentage of functionality
transferred to the new system. Functionality is also important at the conclusion of the
DEPARTMENT OF I.T. 10
D.B.N.C.O.E.T,YTL.
HYBRID RE-ENGINEERING
project, measuring how much functionality is contained within the new system. The
SATC and others are working with function points as a means of estimating
functionality. Function points are comparable across languages, and time estimates
based on function points are available.[6] For COTS packages, functionality might be
measured by the number of requirements satisfied. Quality is harder to measure and few
software developers agree totally on the ppropriate metrics. The SATC has a group of
metrics it applies to projects to evaluate the quality. These metrics evaluate the project
at the module level (procedure, function, class or method). The size is measured by
counting the number of executable statements. The readability is measured by the
comment percentage. The complexity is measured by the cyclomatic complexity
(McCabe). The coupling is measured by the calling complexity (fan in / fan out).[8]
Although there are many other metrics available, these have been successfully applied
to many projects at GSFC NASA. One final measure of quality is the reliability, the
number of errors found, and the projected number of errors remaining. These metrics
can be used for both the translation track and the custom code track. When the
components are combined, the numbers of erro the projected number of errors
remaining can be applied to the whole system
FUTURE WORK
The field of software re-engineering is new, and its risks and metrics are not well
understood. The newest area, hybrid re-engineering, is even less well known. The
SATC is working to define metrics to quantify the quality of legacy systems and of the
re-engineered products, and to provide reliable measures of progress. It is in this last
area, the measure of progress, that we are experimenting with function points.
DEPARTMENT OF I.T. 11
D.B.N.C.O.E.T,YTL.
HYBRID RE-ENGINEERING
SUMMARY
The number of large systems being built from scratch is diminishing, while the
number of legacy systems in use is very high. Rapid changes in the computer industry
continually introduce new hardware and software making older systems obsolescent and
difficult to maintain. Businesses do not want to re-develop from scratch; too many
business decisions are built into the legacy systems. Hence re-engineering. But project
development is always short on time and money, making the need to look at alternatives
necessary. The use of COTS packages is seen as a way to increase reliability while
decreasing development and test time. Translation of code is a means of decreasing time
and cost. This has resulted in a combination of the development methods into a form of
hybrid re-engineering.
REFERENCES :-
[2] Albrecht, A., Gaffney, J. “Software Function, Source Lines of Code, and
Development Effort Prediction: A Software Science Validation”, IEEE Transactions on
Software Engineering, 11/83.
[3] Arnold, R., Software Reengineering, IEEE Computer Society Press, 1993.
DEPARTMENT OF I.T. 12
D.B.N.C.O.E.T,YTL.