# Java: Iterative/Incremental Development

There are many ways to divide the Software Development Life Cycle. I've choosen some common terms, but don't be surprised to see other terms. Here's a brief explanation of the what each means.

- Analysis - Also called requirements analysis. This is the process of figuring out what the customer wants or needs.
- Design - This is the process of deciding how to structure the program. For large projects this is often divided into two stages: architectural design and detailed design.
- Testing - This is the process of trying to detect errors in the program. For large programs this is typically divided into two parts: unit testing tests individual modules and integration testing sees if the total program works when all the modules are run together.

## Waterfall technique -- traditional, but risky

| When you understand a problem and its solution very well, it's possible write a program by following the steps at the left. But problems are rarely understood as well at initially thought, and this "waterfall" approach has turned out to be responsible for an extraordinarily high number of software project failures. There are several reasons for this.

- Mistakes in the understanding the the early phases (eg, requirements analysis and design) that are not discovered until the testing or integration phases are expensive (ie, time consuming) to fix, costing much more time (eg 20x) to fix than if they had been done right the first time. The earlier mistakes are discovered, the easier they are to fix. The cost of finding an error that must be fixed in the completed design or coding phases is usually quite high. Student programs often suffer from this in several ways.
  - The requirements of a programming problem may not be well understood. For example, the instructor may not have written a clear problem statement.
  - If the student is designing their own project, they may not always be clear about what they want. Typically, the idea for a student project evolves as the project progresses.
  - Sometimes the programming solution may not be well understood, and a plan is made based on incorrect ideas about what will work.
- The resources (ie, time) required to complete a program are not accurately estimated (almost always in the optimistic direction). In commercial development this results in late delivery and cost overruns or cancellation. In student programs it means that the program doesn't run, with unhappy consequences.

This are some of the typical reasons that use of the Waterfall methodology is not recommended. An iterative/incremental approach is better.

## Disadvantages compared to iterative method

- The cycle of getting rid of compilation errors can be unnecessarily long.
- The output may not be what you want, but when debugging an entire program, it's harder to identify the source of the error.

## Advantages of waterfall devlopment

Although it is probably responsible for more failures than successes, not everything is bad about this approach.

- By writing the entire program first, you are become aware of problem areas, and take corrective action.
- If the problem is very well understood, this may be the most efficient solution. However, experience has shown that it is frequently inferior to iterative programming.
- It may simply suit your personality better. is this a good reason to use it?

## Iterative and Incremental Development

- Start with a very small version of the program. So small that maybe it doesn't too much besides show some part of the graphical user interface, but doesn't do anything. Test it to make sure it runs ok.
- Analysis. Decide which improvement should be made next. Make a small change.
- Design how you will will code the change.
- Code it and compile to make sure your coding is correct. Often I type only a couple of lines of code before recompiling. Some IDEs, such as NetBeans, does continuous compilation which shows your errors without the need for an explicit compilation request.
- Testing. Run the program, using test data if necessary. If it doesn't run, the program must be debugged and either the coding or design should be changed. Because the last change should have been small, it's usually easy to identify the source of the problem.
- Continue around this loop until the program is finished, or you've run out of resources (time). Using the iterative appoach means that there's a running program at the end of each iteration. It doesn't to everything, but it is something you can turn in. For a company this means that it may be able to use the program for some work and get value out of it before it is finished. It also means that the project can be terminated as soon as the program is "good enuf".

It's often hard for students to restrict themselves to small changes, and they write many, many lines of code. Or to think of it another way, many bugs. The more simultaneous bugs a program has, the harder it is to debug, so keep the number of new bugs to a minimum.

Making very small changes, compiling and testing means that you are much less likely to be faced with a long list of error messages with no idea how to find the problem. A single missing left brace can produce many error messages. If you've only entered a few lines of code before recompiling, you know the error is in those few lines of code and it's much easier to track it down.

## Advantages of iterative development

- You always have a running version of the program, eg, if you run out of time, you can deliver the last iteration, which may not have all functionality, but it does something. This is usually worth more to your instructor than a program which doesn't even compile yet.
- It helps identify the source of the last error (compilation or execution), because you know it's in the code you just added in this iteration. This makes finding bugs much faster.
- It's psychologically more satisfying to get positive feedback on your work, ie, a running program.
- Corrections early in development generally take less time than later in the development process.

## Disadvantages of iterative development

- The iterative approach tempts you to start coding too early. You should have a good idea of what the final program should look like before starting. Unless you're clear on what you want, it's likely that many extra iterations will be required.