Page 74 -
P. 74

CHAPTER 2  THE PROCESS                                              45

                              For this reason, the customer/developer dialog described for other process models
                              remains an essential part of the 4GT approach.
                                For small applications, it may be possible to move directly from the requirements
                              gathering step to implementation using a nonprocedural fourth generation language
                              (4GL) or a model composed of a network of graphical icons. However, for larger
                Even though you use a  efforts, it is necessary to develop a design strategy for the system, even if a 4GL is to
                4GT, you still have to  be used. The use of 4GT without design (for large projects) will cause the same diffi-
                emphasize solid
                software engineering  culties (poor quality, poor maintainability, poor customer acceptance) that have been
                by doing analysis,  encountered when developing software using conventional approaches.
                design, and testing.  Implementation using a 4GL enables the software developer to represent desired
                              results in a manner that leads to automatic generation of code to create those results.
                              Obviously, a data structure with relevant information must exist and be readily acces-
                              sible by the 4GL.
                                To transform a 4GT implementation into a product, the developer must conduct
                              thorough testing, develop meaningful documentation, and perform all other solution
                              integration activities that are required in other software engineering paradigms. In
                              addition, the 4GT developed software must be built in a manner that enables main-
                              tenance to be performed expeditiously.
                                Like all software engineering paradigms, the 4GT model has advantages and dis-
                              advantages.  Proponents claim dramatic reduction in software development time and
                              greatly improved productivity for people who build software. Opponents claim that
                              current 4GT tools are not all that much easier to use than programming languages,
                              that the resultant source code produced by such tools is "inefficient," and that the
                              maintainability of large software systems developed using 4GT is open to question.
                                There is some merit in the claims of both sides and it is possible to summarize the
                              current state of 4GT approaches:
                               1.  The use of 4GT is a viable approach for many different application areas.
                                   Coupled with computer-aided software engineering tools and code genera-
                                   tors, 4GT offers a credible solution to many software problems.
                               2.  Data collected from companies that use 4GT indicate that the time required
                                   to produce software is greatly reduced for small and intermediate applica-
                                   tions and that the amount of design and analysis for small applications is
                                   also reduced.
                               3.  However, the use of 4GT for large software development efforts demands
                                   as much or more analysis, design, and testing (software engineering activi-
                                   ties) to achieve substantial time savings that result from the elimination of
                                   coding.
                                To summarize, fourth generation techniques have already become an important
                              part of software engineering. When coupled with component-based development
                              approaches (Section 2.8), the 4GT paradigm may become the dominant approach to
                              software development.
   69   70   71   72   73   74   75   76   77   78   79