Software Lifecycles

• Software lifecycles (also sometimes called software methodologies or methods) are descriptive/prescreptive models of the stages you do/should go through while developing programs. Here are some of the more common.

• The waterfall life cycle was the first real model of software development, and is still widely followed in some circles. It goes like this:

          Analysis ->
                     Design ->
                              Code ->
                                     Test
  

  The major problem with the waterfall life cycle is that you don't get any working program until the end, so analysis (finding out what the user wants) and design bugs may go unnoticed until it is far too late. This problem can be partly aleviated by using CASE (computer assisted software engineering) which allow you to model your program design in some formal language and check it for consistency.

• A popular alternative to the waterfall life cycle is the prototype spiral:

                  Analysis   ->   Design
                    ^               |
                    |               v
                   Test      <-    Code
  

  In each iteration of the spiral, you take some small chunk of what the user wants, analyze them, figure out how to add them to the code you have already, add them to your prototype program, then test them both for bugs and for how well they meet the user's desires. Analysis and design bugs may still occur, but they are spotted sooner and don't affect as much code.

• There are many other life cycles in the software engineering literature and in practice, but they are usually only used when dealing with really really large programs. The only other programming methodology we will talk about is object oriented programming, which isn't its own software life cycle, but rather a different way of doing the steps that make up a software life cycle.