The Software Life Cycle

The software life cycle refers to the whole process of software development, since its building starts and ends, including maintenance and evolution in time. This life cycle defines how we are going to carry out the software process, in which a framework of the tasks needed to build high quality software is established. This is important because the activities to be performed are defined, control points are provided and it makes organizing the different activities that are carried out easier.

Its origin lies in the fact that it is very expensive to rectify the potential errors that are spotted late in the implementation phase. Using appropriate methods, they could be detected on time, so that programmers can focus on software quality, meeting the deadlines and related costs.

 Phases and Stages

The methodology for software development consists in the processes to be followed systematically to design, implement and maintain a software product since the need of the product arises until the goal for which it was created is met.

Broadly speaking, here are the phases:

  •   Definition Phase: It focuses on WHAT.

What information will be processed

What performance is wanted

What behavior must it have

What interfaces

What restrictions

What criteria

  •   Development Phase: It focuses on HOW.

How to design data structures

How to implement functions in the architecture

How are procedures and interfaces implemented

Programming language

How testing will be 

  •   Maintenance Phase: It focuses on CHANGE.

Defect correction

Adaptation to changes in its environment

Improvement, incorporating additional functions

Prevention, also called software re-engineering

  •   Protective Activities:

Quality assurance

Risk management


 Taking into account software phases, we can extract the classic stages of software development that we have to consider when developing:

  1)    Requirements Gathering:

  It’s the process of figuring out, normally in difficult circumstances, what needs to be built. This is complicated because often users don’t know the requirements, nor how to specify them accurately. In short, this stage is intended to discover and gather each and every functional and non-functional requirement of the app to be defined clearly and briefly.

 2)    Analysis:

  During this stage, we analyze the requirements that were described in the requirements gathering stage, refining and organizing them. The goal of this is to get a more accurate understanding of the requirements and a description of them that is easy to maintain and that helps us organize the whole system. 

3)    Design:

  It assigns portions of the essential model to appropriate processors and tasks. Within each task, a hierarchy of interfaces and program modules is defined to implement the specification created in the analysis. Databases are designed. The user implementation model is developed, which describes the interfaces and the human-machine boundary. Possible implementation options for the software that has to be built are studied and its general structure is also decided. Design is a complex stage and its process must be done in an iterative manner.

 4)    Implementation:

  In this stage, we have to choose the appropriate tools, a development environment that makes work easier and a programming language suitable for the type of software to be built. These choices will depend both on the design decisions taken and also on the environment in which the software must run. It includes coding and integration of modules into a gradually more complete structure of the final system.

 5)    Testing:

  The aim is to detect errors made in previous stages in order to correct them. Of course, it’s ideal to do this before the end user comes across them.

 6)    Integration:

  It means putting the software into operation, so we have to plan the environment taking into account existing dependencies between the different components.

 7)    Maintenance:

  This is one of the most important stages of the software development life cycle. As software neither breaks nor wears down with use, its maintenance includes: eliminating the defects detected during its life cycle, adapting it to new needs and adding new functionalities.

Software Life Cycle Models

Classic Model:

Sequential, Linear or Waterfall Model:

  Sequential progression from one phase to another. In this way, only when a phase finishes, we will be able to continue with the next one, and so on.

Structured Model: Incorporation of structured analysis and structured programming. Tasks can be done in parallel and links between activities and finishers are established. Descending implementation.

  •     RAD (Rapid Application Development):

It’s a linear sequential model that emphasizes a very short development period.

Evolutionary Model: It’s a model that considers the software evolutionary nature. It’s iterative; it’s characterized by the way in which it allows engineers to develop increasingly more complete versions of the software.

  • Incremental Model:

  Each linear sequence produces a software increment. The first increment is an essential product that is later completed. With each increment, an operational product is delivered.

  • Spiral Model:

The software is developed in a series of incremental versions. During the first iterations, the incremental version could be a prototype. During the last iterations, increasingly more complete versions of the system are produced. This model can be adapted and applied throughout the software life. The spiral remains operational until the software is withdrawn. The model uses prototype building as a mechanism for risk reduction.