Introduction

The software development life cycle is designed to ensure that software is feasible, required, well designed and thoroughly tested. You need to know about 5 different software methodologies. Stages include:

• Feasability - is the problem solvable? Think about costs, current technology, time frames etc.
• Requirements - what features should be included?
• Analysis and Design - how should we create the solution?
• Implementation - creating the solution.
• Testing - Check that all features work as intended.
• Deployment - installing the software.
• Evaluation - How successful was the solution for our end users?
• Maintenance - ensuring that the software continues to work.

Software Models

You will need to know about the following software models:

1. Waterfall
2. RAD - Rapid Application Development
3. Spiral
4. Agile
5. Extreme Programming

The Waterfall Model

Requirements are defined and documented from the outset. Each stage has a distinct with clearly defined deliverables. Stages are completed in a specific order, but it is acceptable to move back one or more previous stage(s) to make refinements. But then the project must go forward through the stages in order again.

Advantages of this model are that it is simple and easy to manage as it has clear goals for each stage. It is therefore easy to tell if the project is on track. Themain disadvantage is that it is inflexible. Most stages are completed before there is a product which can be demo'd to end users for feedback. Although the user may be consulted at different points. So if requirements have been misunderstood time and money have been wasted.

Therefore it is only used for large scale projects with well understood and clearly documented requirements.

RAD - Rapid Application Development

RAD involves the development of increasingly refined prototypes. There is no formal analysis or design stage. The software feasibility is assessed first and then each prototype is designed and produced. Each prototype is demo'd to the end user for feedback and further requirements. This process continues until the user is satisfied and a final version is produced.

Advantages are that requirements can be refined through out to suit the needs of the end user. So it is likely to be fit for purpose. It also can lead to faster development. However a main disadvantage is that it doesn't lend itself to writing well planned, efficient code. You also need regular access to the client which is not always possible.

Therefore this model is not considered suitable for large products. But it is good for smaller projects with less defined requirements.

The Spiral Model

The Spiral Model is a risk driven model. The spiral model is otherwise not fixed and allows software teams to include other models. The main steps include identifying objects, identifying risks, development and test, plan the next prototype.

Thereisn't a fixed number of iterations. As this process continues, risks should reduce. Once the team is comfortable with the prototype an operational prototype. At this stage, the software team can fully plan the prototype much like planning in the waterfall model.

The advantage of this is that it is suitable for high risk projects. However, a disadvantage is that specialist (and often costly) experts may be required to assess risks accurately. If this fails, the project will also fail.

Thus this model is suitable for large scale programs especially if the requirements are not well defined.

Agile Development

This is a fairly modern group of methodologies. The main focus is that requirements often change and thus iterative prototyping is required. These are built in sprint cycles (short, time-boxed periods of no longer than four weeks).

Extreme Programming

This is more of a framework which will support the production of high quality code and a more content software team. It encourages collective code ownership with each team member being of equal value. This requires high code standards. The Like the agile development model, it promotes the production of small iterative prototypes produced in a short time frame. Key concepts include:

1. Collective Code Ownership.
2. Code Standards - to ensure high quality code.
3. Paired Programming - two developers sat side by side to produce higher quality code.
4. Continuous integration - to ensure that the code is fit for purpose.
5. Refactoring - refining and repurposing old code,

Agile and Extreme Programming - Pros and Cons

The advantage is that this model focuses on programming in collaborative teams, which is likely to produce high quality code. However, a disadvantage is that it does require programmers who working closely together in the same geographical space. This also involves very regular contact with the client who needs to be embedded into the development team. If the focus is quality of code Agile and Extreme programming are ideal.

Designing Algorithms - Flowcharts and Pseudocode

Watch the following video for a fuller understanding of how to create a flowchart and how to write pseudocode.