Page 266 -
P. 266

9.3   Software maintenance  249



                            Original                         Program       Reengineered     Original Data
                            Program                       Documentation      Program

                                            Reverse
                                          Engineering

                          Source Code                        Program                   Data
                           Translation                     Modularization          Reengineering

                                            Program
                                           Structure
                                          Improvement
                                                           Restructured            Reengineered
                                                             Program                   Data



                                       2.  Reduced cost The cost of reengineering may be significantly less than the cost
                     Figure 9.11  The
                     reengineering process  of developing new software. Ulrich (1990) quotes an example of a commercial
                                          system for which the reimplementation costs were estimated at $50 million. The
                                          system was successfully reengineered for $12 million. I suspect that, with mod-
                                          ern software technology, the relative cost of reimplementation is probably less
                                          than this but will still considerably exceed the costs of reengineering.


                                         Figure 9.11 is a general model of the reengineering process. The input to the
                                       process is a legacy program and the output is an improved and restructured version
                                       of the same program. The activities in this reengineering process are as follows:

                                       1.  Source code translation Using a translation tool, the program is converted from
                                          an old programming language to a more modern version of the same language
                                          or to a different language.
                                       2.  Reverse engineering The program is analyzed and information extracted from it.
                                          This helps to document its organization and functionality. Again, this process is
                                          usually completely automated.

                                       3.  Program structure improvement The control structure of the program is ana-
                                          lyzed and modified to make it easier to read and understand. This can be par-
                                          tially automated but some manual intervention is usually required.
                                       4.  Program modularization Related parts of the program are grouped together and,
                                          where appropriate, redundancy is removed. In some cases, this stage may
                                          involve architectural refactoring (e.g., a system that uses several different data
                                          stores may be refactored to use a single repository). This is a manual process.

                                       5.  Data reengineering The data processed by the program is changed to reflect
                                          program changes. This may mean redefining database schemas and converting
                                          existing databases to the new structure. You should usually also clean up the
   261   262   263   264   265   266   267   268   269   270   271