5.1 Overview of the Production Process


Producing a reliable, executable system from the files containing the classes' implementation is a process that involves three key steps:

  1. rebuilding the executable system from the current implementation,
  2. testing the system by executing it under varying conditions to reveal errors in the system , and

  3. debugging the current implementation by locating and correcting the mistakes made in the system's implementation or design that led to these errors.

These three steps are, of course, iterative: correcting a programming mistake leads to rebuilding a new executable that is further tested and debugged. Ideally, the correction can be accomplished by a small, localized change in a single class. A weak class design or a weak system design, however, can create situtations in which extensive changes in many classes, or a major redesign of the entire system, is needed to correct an error. Careful attention to class and system design during the earlier phases of the development process is the best way to minimize backtracing to the design phase when testing and debugging.

Developers must be proficient users of tools that automate the mechanical aspects of the production process. Tools that automate the rebuilding task allow developers to operate more efficiently and more reliably. The tools relieve the developer of the burden of managing a large amount of straightforward, detailed information about the steps needed to rebuild the system and he or she is thus able to operate more efficiently: less attention need be given to the mundance rebuilding task and more effort can be devoted to the critical tasks of design and implementation. The developer is also made more reliable, because the tools are more adept at retaining all of the detailed information about how to rebuild the system. Fewer mistakes, therefore, occur in the mechanical aspects of rebuilding the system. Debugging tools yield information about the system during execution without the need for any preprogramming. These tools make it easier for the developer to examine the state of the executing system and control the system's execution during the debugging task. The developer does not need to insert, and later remove, code to obtain this information and control.

The material presented in this chapter focuses on the production tasks of rebuilding and debugging and excludes other equally important topics that are simply beyong the current emphasis on object-oriented programming. The testing process, for example, is important in developing realisitic systems: a more advanced course in software engineering should present techniques for generating test cases and test scenarios, criteria for measuring how completely the system has been tested, and models for estimating the system's reliability. Other important tools that help in the rebuilding process but are beyond the scope of this chapter include: code control tools which are critical for integrating coherently the work of several developers producing parts of the same system, generating a consistent version of the system, and retaining a history of the changes made to a system during development so that previous versions of the system can be recovered.

©1998 Prentice-Hall, Inc.
A Simon & Schuster Company
Upper Saddle River, New Jersey 07458

Legal Statement