Further Links Contact Us Search Help

Syllabus | Exams | Assessment | Resources | Site reviews | Careers

Software Design and Development

Home > Software Design and Development > Core > Software Development Cycle > Software development cycle

The software development cycle

The stages for the software development cycle are as follows:

• Defining and understanding the problem
• Planning and design of software solutions
• Implementation of software solution
• Testing and evaluation of software solution
• Maintenance of software solution

Activities

Outcomes

This material addresses aspects of the following syllabus outcomes:

A student:

Source: Board of studies NSW, Stage 6 Software Design and Development, Stage 6 Syllabus (1999)

The Software Development Life Cycle relates to models used to manage the development of systems. The cycle is also commonly referred to as the ‘waterfall model’. It is a sequence of stages in which the output of each stage becomes the input for the next. These stages generally follow the same basic steps but there is not a definitive correct model. A number of different models have evolved including fountain, spiral, build and fix, rapid prototyping, incremental, and synchronise and stabilise.

Project management

Project management happens throughout this development cycle, it involves setting up a project team and assigning different roles to team members. A range of tools are used to manage the progression of the project such as Gantt charts, PERT charts, logs and documentation.

Defining and understanding the problem

This first stage of the development cycle involved developing an understanding of the problem and WHAT needs to be solved. This typically consists of a number of activities: identification of the problem, idea generation, representation of the problem and communication with others involved in the proposed system. These activities are not necessarily distinct and may overlap. One may be undertaken simultaneously with another depending on the requirements and time constraints of the project.

Identification of the problem

This stage involves examining the client requirements and the operation of the existing system. A list of requirements for the new solution is created and analysed, along with any areas which the client has identified as lacking in the existing system.

Ideas generation

At this stage the problem is analysed in more detail in order to generate ideas for possible solutions. A number of ideas are generated for consideration. These ideas are then included in a feasibility study which is presented to the client. The feasibility study includes analysis of the different ideas and their positive and negative features and makes a recommendation as to the most desirable solution.

More information on determining the feasibility of software is available here:
http://www.hsc.csu.edu.au/sdd/core/cycle/feasibility/feasibility.html

Representing the system using Modelling diagrams

After defining the problem, it now needs to be examined in greater detail. This information about the problem and the new solution can be represented using a range of modelling tools including:

• Input Process Output (IPO) diagrams
• story boards
• data flow diagrams
• systems flowcharts
• screen designs
• consideration of use of a limited prototype

Interface design

At this stage a decision is made to determine whether a graphic or text based interface will be used.

Selection of appropriate data structures

Appropriate data structures such as structured data types or simple data need to be decided on. This will depend upon the data required by the system and the complexity and use of the data.

Communication with others involved in the proposed system

It is very important to obtain feedback from users of the system at all stages of the cycle. This is essential if the software solution is to meet the requirements of the client. In the initial stages of the project meetings will take place between the client and the project team. Time spent in consultation with users help to make the new system as productive and cost efficient as possible.

Consideration of social and ethical issues

Consideration needs to be given to social and ethical issues that relate to the development of the system and the finished product. These issues include:

• Ergonomics
• Ease of use
• Accessibility of technical language
• Copyright.

Planning and Design

The second stage of the development cycle focuses on HOW to solve the problem, creating and documenting a solution to the problem identified in the first stage. Some of the tasks that can be done include:

Interface design

An interface is designed to be efficient and easy to use. Some basic guidelines are followed such as requiring a minimum number of mouse clicks to locate information, replication of hard copy forms in interface design, layout consistency and ensuring that the tab order follows logically.

Selection of software environment

Selection of software environment is dependant on a number of factors including how and where the system will be used and the expertise of programmers. Examples of software environments are web-based, Unix and Windows.

Identification of appropriate hardware

Hardware that is appropriate to system requirements needs to be selected. Diagrams of the workplace layout are useful in component selection.

Design and documentation of the overall software solution

The design of a complex solution needs to be created. This solution then needs to be represented, using a range of documentation techniques:

• algorithm descriptions: Represents the logic of a program or function using pseudocode or flowcharts.
• system flowcharts: Represents the flow of data and the logic of the system.
• structure diagrams: Represents the overall view of the solution, showing the processes or subtasks to be coded, their relationships and the data passed between them.
• data flow diagrams: Represents the processes of the solution and the source and movement of data between processes.
• data dictionary: Represents the data (variables) to be held.

Implementation

In this stage the solution is created. The documented design in the previous stage is implemented, e.g. algorithms are converted into code using a programming language. Documentation relating to the conversion of the existing system to the new system is created. Online help is often included to explain program functions.
There is a range of program development techniques that can be used in the implementation of the software solutions, they include:

• using a structured approach to a complex solution:
  • one logical task per subroutine: each subroutine should only perform one logical task.
  • stubs: used to represent parts of a program yet to be written.
  • flags: used to represent whether a process has been carried out.
  • isolation of errors: use of flags for error detection, manually stepping through a program, display of each line being executed by a software development system.
  • debugging output statements: temporary output statements placed within code to assist with the debugging process.
  • elegance of solution: the production of clear and simple algorithms.
  • writing for subsequent maintenance: the use internal and intrinsic documentation, structuring of the algorithm and the use of identifiers for variables and constants.
    
    
• the process of detecting and correcting errors:
  • syntax errors: where the written code does not conform to the rules of a programming language.
  • logic errors: usually detected at the algorithm checking stage; errors where algorithm.
  • run time errors, including:
  • arithmetic overflow: The result from an arithmetic calculation that exceeds the space designated to hold it.
  • division by zero: error caused by attempt to divide a number by zero.
  • accessing inappropriate memory locations: program attempts to access an element that does not exist.
  • peer checking: code is checked by other programmers.
  • desk checking: an algorithm is manually checked with test data.
  • use of expected output: inclusion of expected program output when test data is created.
    
    
• the use of software debugging tools:
  • use of breakpoints: points at which a program is made to stop during execution.
  • resetting variable contents: resetting values of variables within a running program to observe the effect of processing within a section of code with known values.
  • program traces: printing or displaying the line number or identification of each statement as it is executed to detect errors.
  • single line stepping: following the values of variables from line to line during program execution to detect errors.

Testing and evaluation

Testing the software solution

A comparison of the solution with the original design specifications is made. Appropriate test data is identified to ensure the system correctly carries out the tasks it was designed to perform. The program is divided into smaller modules and as each module is completed it is tested in order to minimise recoding.

Reporting on the testing process

Documentation of the test data and output is produced often with the use of CASE tools. These results are communicated to those for whom the solution has been developed.

Maintenance

After the system has been implemented, constant monitoring and evaluation is carried out to ensure the system continues to function efficiently. Modifications to code and scripts is often required. Original documentation is important, as is the structure and self-documentation of the commands to be updated.

Modification of code to meet changed requirements

• Identification of the reasons for change in code, macros and scripts.
• Location of sections to be altered determining changes to be made.
• Implementing and testing the solution.
• Documentation of changes.
• Source code, macro and script documentation.
• Modification of associated hard copy documentation and online help.
• Use of CASE tools to monitor changes and versions.

Activities

1. Identify the documentation tools and techniques that are used in each stage of the development cycle.
2. Create a system flowchart which briefly outlines what happens at each stage of the System Development Cycle. Use correct flowchart symbols and include logical decisions. On completion of the flowchart, translate the steps into pseudo code.
3. Document a software project which you intend to develop in terms of the System Development Cycle. Include information on what procedures you needed to carry out at each stage.
4. Case study: contact an IT professional at a local business or organisation that has implemented a software solution. Prepare a questionnaire prior to an interview. Create a report which outlines how the System Development Cycle was carried out.

References

Fowler, A. (2003) Software Design and Development, HSC Course, Heinemann, Melbourne.
Board of Studies NSW, Stage 6 Software Design and Development, Stage 6 Syllabus.
Systems Development Life Cycle, Wikipedia http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle   26/06/2008