Software Development

There are many possible definitions and descriptions of software development but a useful introduction can be found at http://www.startvbdotnet.com/ and the material we present in this section is based on this introduction. `Software development is the process of developing software through successive phases in an orderly way'. The obvious stage in the process is the actual writing of code but before this there are stages that include preparation of requirements and objectives, and the design of what is to be coded. Then following the coding stage the software must be tested to confirm that what has been developed has met the requirements identified at the outset. Before software development methods were recognised the development of new software often had very little a-priori requirements specification or design thought code did get written and tested to ensure it `worked'. Often the trouble would then be the lack of documentation of the methods used or choices made during implementation leaving those charged with maintaining such software with a learning curve steeper than it might otherwise have been! The complexity of modern systems and computer products long ago made the need clear for some kind of orderly development process. The different phases involved in software development are as follows:

1. Identification of required software
2. Analysis of the software requirements
3. Detailed specification of the software requirements
4. Software design
5. Programming
6. Testing
7. Maintenance

The software development process is guided by some systematic software development method (SDM), also referred to by a number of terms, like process models, development guidelines, and systems development life cycle models (SDLC). The are many approaches to development taken by SDLC models. Some of these models include

The Waterfall Model

- A classic SDLC model, with a linear and sequential method that has goals for each development phase. The waterfall model simplifies task scheduling, because there are no iterative or overlapping steps. One drawback of the waterfall model is that it does not allow for much revision.

Rapid Application Development (RAD)

- This model is based on the concept that better products can be developed more quickly by using workshops or focus groups to gather system requirements.

Joint application development (JAD)

- This model involves the client or end user in the design and development of an application, through a series of collaborative workshops called JAD sessions.

Prototyping Model

- In this model, a prototype (an early approximation of a final system or product) is built, tested, and then reworked as necessary until an acceptable prototype is finally achieved from which the complete system or product can now be developed.

Synchronize-and-Stabilize

- This model involves teams working in parallel on individual application modules, frequently synchronizing their code with that of other teams and stabilizing code frequently throughout the development process.

Spiral Model

- This model of development combines the features of the prototyping model and the waterfall model. The spiral model is favored for large, expensive, and complicated projects. (where the costs and end date spiral out of control!)

We shall consider the `waterfall' or `cascade' lifecyle model for software development illustrated in Figure 1 and give a brief description of the stages below.

Figure 1: The Waterfall Model of Software Development

Feasibilty

The feasibility study determines whether a particular development project should go ahead. If the project is to proceed then a project plan and budget estimate for the other stages of development will be produced.

Requirements analysis

The requirements for the new or modified system are gathered at this stage. They should be recorded so that at the end of the project the software can be tested to ensure it fulfills the requirements.

Design specification

Design focuses on:

• high level design, e.g. what programs are needed, what are their inputs and outputs, what are their interactions with other software or the operating system.
• low level design, e.g. how will the program work, what models or algorithms will be used, what libraries are required.
• data design, e.g. for input and output, data structures in the software.

The level of detail in the design may be a matter of personal choice or may be specified by particular development procedures. Having a detailed design will make generating the code easier but will make changing things difficult whereas a more broad brush design will leave more work in the implementation phase but allows room for the details to come out as the development progresses. Above all the design should be documented including reasons for making particular choices if a number of options were available. This makes it much easier for new developers to join a project and helps when new features are required.

Coding

In this phase the designs are translated into code. Programming tools such as compilers and quality assurance tools are used to generate good quality source code and the software application. Testing of small self-contained parts (modules) of the overall application may take place depending on the modularity of the code.

Testing

The overall system is tested to ensure that it works on the intended plaform(s), giving correct results or showing the required behaviour defined in the requirements document. The use of debuggers and profiling tools will be useful at this stage to identify errors in the code and get the best possible perfomance from the code. Optimum performance is especially important in scientific computing applications.

Maintenance

Once the system is delivered to users it will inevitably need maintenance. There may be bugs caused by unexpected input values (add them to a test suite) or by unexpected (inappropriate) use of the software (tighten up the documentation). In addition users will want more or different functionality and will definitiely want it to run faster or address bigger problems! The software development process should be able to accommodate changes at this stage through a well thought out design and any changes should have their own requirements, design, coding and testing stages.

We are interested in tools aimed at the following stages of the cycle:

• Coding and unit testing
• Integration and system testing
• Delivery and maintenance (especially of legacy code).

For the remainder of this report we will take each of these stages and consider the tools that may help a developer produce high quality software