he following diagram draws from the sphere of engineering, showing the traditional (also known as classic) and most straightforward approach to constructing software, the Waterfall Software Life Cycle Model. You can modify this plan to your needs, as the aim is to give you a starting point from which you can properly consider the work ahead. All modern software development models, including RAD and XP, have their roots in this approach.
On the diagram, there is some scale implied in the length of the boxes left to right. Notice that the arrows can feed back up the process. This is important because if things start to go wrong somewhere down the line, you may need to back up one or more steps to get to the reason why.
This is literally just the idea, the first inspiration, the vision. This really is the realm of dreams, but realising the dream is where the Waterfall model comes in.
This is the stage where the nitty gritty of the idea begins to be explored. What is involved? What will it need to make it happen? How long will it take? And the all important question: is if feasible?
Often an idea will be reconsidered, or at least tempered at this stage, and that’s fine. In fact, it’s probably desirable, because it means that the concept is being fully explored, and thought is genuinely being given to what can be achieved with the resources available. It’s a lucky idea that has unlimited resources!
Feeding from your analysis, you begin to design. This stage will often feed back and forth a lot with the analysis and the idea, because issues can begin to come to light at this stage that perhaps weren’t apparent previously. The design should of course be based on the analysis, and for the project to have any hope at all the design must keep in mind the constraints that the analysis has put in place.
Clearly, this is where the project starts to be built. There is obviously a level of commitment at this stage, and the previous work is relied on. There is still the facility to move back up the waterfall if required, even as far back as rescoping the idea if necessary, but the further down the waterfall a project has gone the more damaging it is to cycle back up to earlier stages.
Test test test! Then test again!
Seriously, it should be very obvious that almost a full half of the project’s time scale is taken up with testing. Don’t underestimate this, as you can easily end up with a very expensive piece of binary junk. Testing of software, from websites to banking applications, is a huge subject, but it’s a simple concept. Just think how frustrated you become when you use software and perhaps lose hours of work because of a bug. And that’s just a minor problem. Internet crime is largely able to exist by exploiting bugs and weaknesses in poorly tested software. So, whatever you’ve made, test it as thoroughly as you can.
This is when you unleash your project on the world! Of course if the idea has been properly analysed, properly designed, well constructed and fully tested, it will simply work straight off the bat. Sadly, this is rarely the case. So, this is an intense period, where there may be much flurry of new analysis, redesign, reconstruction and renewed testing. Regardless of how well you feel that you’ve gone through the process, it’s best to have a everybody involved on the project alerted and ready for action at this point. If it works out, great, but if you have to react, make sure that you can.
You need to keep up with the project. In part this does mean that you should watch for bugs and other errors that are reported to you, and fix them. Yes, even your extensive testing regime may well have missed the odd issue here and there!
Just as importantly, though, is to keep developing the project. New ideas, new improvements, and simply bringing things up to date with the changing world (new currency for example!) are just as important to maintaining a project. Software and websites rarely need to die, as long as they are maintained. Look at everything from Windows to the Yahoo! website – the key to their longevity is that they are constantly renewed and updated. Keep the project fresh, relevant and useful, and it will survive.