Overview The past Introduction

6.4 The stage-wise and classical waterfall models conventional models 119 n It can be costly to maintain because of its poor structure and lack of definable output that can be tested. Although the build-and-fix approach is still used today by many programmers working on small and personal systems, you should not be using it for your project. You should, instead, look to one of the more defined and recognised processes outlined in the following sections. •

6.4 The stage-wise and classical waterfall models conventional models

Because of the problems encountered with the unstructured approach of the build-and-fix model, several more detailed models were devised. The earliest of these models was the stage-wise model from which the classical waterfall model developed. The stage-wise model was developed in 1956 by Benington in an attempt to provide an engineering process to the development of software. It represents a unidirectional, sequential process – once a stage has been completed, the results of that stage become a fixed baseline from which the following stages develop – there is no revision. While this appears to be rather rigid and naïve, the development of a defined process at that time was a significant breakthrough in software engineering. It was soon recognised, however, that the sequential nature of the stage-wise model was causing problems and some form of reworking was required in order to allow a user’s needs to be addressed more effectively. For this reason the classical waterfall model was developed – shown in Figure 6.4. The classical waterfall model differed Figure 6.4 The classical waterfall model 120 Chapter 6 n Software development from the stage-wise model in that it allowed some limited iteration between stages – shown as ‘splashing back’ in Figure 6.4. Figure 6.2 highlights one of the main problems with the conventional waterfall-type approaches. As we move through the stages of the process the problem we are trying to solve is not static and moves on shown by the shifting problem ovals with respect to time in Figure 6.2. Thus, by the time we complete our analysis, design and building of the software system, the program we present to our user no longer solves the problem they currently have – i.e., the software is already obsolete. Another problem is that the user’s understanding of the problem is unclear and there are ambiguities in the subse- quent requirements specification. We cannot then guarantee that the system we design and develop is matching the user’s needs at all. The conventional approach to software development is, therefore, only really appropriate for projects that are: n short say six months to one year maximum – a typical student project length so that the problem does not have time to evolve; and n understood clearly – so that the initial requirements are captured accurately and subse- quent specifications and designs are very close matches with what is actually needed. You should, therefore, only use this approach for your own project if you are confident that you fully understand the requirements of the system or they have already been provided to you in an unambiguous way by the client. In most cases we cannot guarantee to fully understand the needs of our user – in which case one of the following approaches is perhaps more suitable for you to follow. •

6.5 The incremental model

Rather than delivering your software to your client towards the end of your project in one ‘big bang’ as the conventional models do, it might be better to deliver the system to them as a series of intermediate working sub-systems over a period of time. Thus, you add more functionality to the software at each release of the system. This means that you need to get an overall software structure kernel in place as part of the first release of your system. The other parts of the system are then brought on-line and released to the user as the system is developed. Thus, each release to the user provides added functionality to the existing system. In a project lasting around six months you would not really expect to have more than three releases. Figure 6.5 adapted from Ould, 1999 illustrates the incremental model – in this case there are three incremental releases for the system. Notice that the requirements for the system are gathered in the usual way at the start of this process. You then design and prepare the first release of the system. This includes a kernel for your program and the first component of functionality that will be useful to the client. The second phase of the process involves designing the second increment of the system and developing and implementing this within the existing system. This process continues until all the increments have been completed and the system is fully working. Figure 6.5 also highlights two other aspects of the incremental approach. The first point to note is that the design stages of the later increments are not as detailed as the design stage of the first incremental release. This is because the first increment of