Development Stages

The System Development is the interactive process which consists of the following stages. These stages may vary slightly depending on which book you are reading or which model you are following.

Sometimes software needs to be written to specific criteria rather than be purchased from a shop. There are times that software must do specific things that just cannot be done by software that is purchased off-the-shelf. When this occurs, software development is undertaken during the development phases of the SDLC. A separate set of steps are engaged for the development of software. As seen in the image below these steps are:

  • Analysis
  • Design
  • Development (coding and debugging)
  • Testing
  • Documentation
  • Implementation and
  • Evaluation

Programs are logical sets of instructions that can be understood and executed by a computer. They are used to direct the computer to perform the functions that transform data into information. Programs are usually developed using a general-purpose information-processing language comprising sets of symbols and codes that are used to construct a logical sequence of instructions.

Some programming languages are designed to create programs for particular purposes but can be used for other purposes as well. For example, COBOL is used for business applications, Fortran for scientific and engineering purposes, Lisp for creating artificial intelligence programs, Java for developing programs that run on a range of hardware platforms, dBASE for producing database applications, Visual Basic for Applications (VBA) is used with Microsoft products such as Access, and Excel to customise the way they process data.

If a decision is made in the design stage of the SDLC to use custom-built software, then a set of program specifications is produced. They specify the data and the input-processing-output components of the program to be developed. When the development stage is underway, program to be developed. When the development stage is underway, program specification are given to the programming team so they can start work. As the program is developed, it progresses through the following series of stages.

Analysis Stage

The analysis stage revisits and analyses the program specifications that come from the design phase of the SDLC. The program specifications usually contain:

  • a list of data
  • requirements for input and output
  • descriptions of the processes that will be used to transform the data into information

These are described using design tools such as data dictionaries, context diagrams and dataflow diagrams (DFDs), structured English and flowcharts.

The purpose of analysis is to understand and specify the exact requirments of the program to be developed and built. The same design tools can be used again to represent the conceptual design but with more detail of course. In addition to the factors that were considered in the SDLC design phase, the analysis in software development can be involve interviews with the system designer and with the future users of the programs so that a clearer understanding of the requirements is communicated.

Design Stage

Tasks in the design stage are broken down into smaller parts. For example, a large program is broken down into modules and then further divided into smaller modules. This process is called top-down decomposition design. The process is finished when each module is clearly and simply defined, and small enough to be coded as a single program. If only a part of the software needs to be developed the process is called bottom-up design as the new software has to be compatible with the rest of the software.

The first step in the design stage is to define the structure of the overall program and the relationship between the modules and represent them in a structure chart. At the same time the layout diagrams of the input and output screens and reports are produced.

The next step is to define the purpose and method of operation of each module as an algorithm. An algorithm is a description of a procedure or set of instructions required to perform a specific task, and contains descriptions of the data to be used. Various design tools can be used to represent the algorithm, such as flowcharts, Nassi-Schneidermann diagrams and structured English (pseudocode). The algorithms for the modules must be clear for the programmer to work from without the need to clarify them with the designer. The method used to represent the structure and the algorithms depends on the type of programming language chosen. If an object-orientated language is to be used the representation would be different from that used for a procedure-based language.

The last part of the designs stage is checking the logic of the algorithms. This is checked using specially designed test data and a process of stepping through the alogrithm called desk-checking. It is much easier to correct errors in the design stage than when the program has been written.

Development Stage

The development stage consists of two components: coding and debugging. These components are done in an iterative manner, moving from debugging back to coding, and then debugging the new code, and so on until all errors are found and removed.

Coding

Coding occurs when errors are removed from the code. Errors are generally of two types:

  • Syntax errors, which are often spelling mistakes.
  • Logic errors, which give wrong results. The same test data that was used in the design stage desk-checking is used to check the logic as the results are already known.

Modern languages have extensive debugging tools built into an integrated development environment (IDE) that allow tracking of the value of variables as the program is run instruction by instruction. These tools greatly assist in the debugging process as the results of each step are checked.

Testing Stage

The testing stage is where the actual program is checked against the program specifications from the SDLC design phase. This often involves testing by some of the end users of the program.

Program Documentation

Program documentation includes both external and internal documentation. External documentation also includes:

  • technical documentation
  • the original program specifications
  • the various designs and test data from the previous stages
  • operating instructions and user’s manuals.

Internal documentation includes:

  • the code with full internal documentation
  • description of variables, files and data structures
  • introductions to each module and code structure
  • comments on lines of code that are not easilty understood.

Implementation Stage

The implementation stage invovles the installation of the program in the environemtn where it will be tested against live data with trained users. This type of testing is often more thorough than specially designed test data. The implementation may only involve a small number of the end-users to begin with and then extend to all the staff and branches.

Evaluation Stage

The program is usually evaluated some time after it has been fully implemented within the organisation. This is known as the evaluation stage. The program is evaluated against criteria that are specified in the program specifications and feedback from the users.

After the software development implementation and evaluation stages, the completed software then rejoins the System Development Life Cycle. The SDLC has its own implementation and evaluation stages. The implementation and evaluation of the software needs to be integrated with the implementation and evaluation of the full information system.