We currently live in such a digitalized world that we have reached a point where we have managed to have control of all our business processes at the fingertips. However, companies wishing to guarantee their validity in the market and increase their efficiency, must know not only how to take full advantage of the solutions available to them, but also have solutions that include the best software development methodologies that allow that the management of their business processes are much more agile.
The development of a software in itself is complex, it is usually not viable to achieve 100% reliability of a program no matter how small. There is a great combination of factors that make it impossible to carry out a thorough verification of all possible execution situations that may arise. Using the creation of an operating system as an example, this is a task that requires a project, management, numerous resources and a disciplined team of work. A software development is imperceptible and usually very abstract, this puts obstacles in the definition of the product and its requirements, more than anything when there is no defined precedent for a similar software development. This situation will make the requirements difficult to consolidate beforehand. This is why now changes in requirements are inevitable, not only after the product is delivered but also during the development process. Whatever the process used and applied to software development, almost always freely of this process, a life cycle model must be applied. According to several consulted sources it is estimated that, of the total of large software projects undertaken, 28% fail, 46% fall into severe modifications that delay it and 26% are totally successful. When a software development project “fails” (28% statistically), it is very rarely caused by technical failures, mainly the origin of failures and failures is the lack of application of a good methodology or development processes. A strong trend, since a few years ago, is to improve methodologies and processes, or create new ones and encourage IT professionals in their proper application, usually using their specialized knowledge with models, paradigms and obsolete processes that were already designed.
What is a Software Development Methodology?
A software methodology is an approach, a way of interpreting the reality or the discipline in question, which in this particular case would correspond to Software Engineering. In fact, the methodology for software development is considered as a structure used to plan and control the procedure of creating a specialized information system.
Having said that, we show below what are some of the development methodologies that will allow you to know which would be the most appropriate for your business:
- Cascade model.
- Spiral model.
- Prototype Methodology.
- Rapid Application Development (RAD)
- Extreme Programming Methodology (XP)
1. Cascade Model
The cascade model is a process of sequential development, in which the software development is conceived as a set of stages that are executed one after the other. It is named for the positions that occupy the different phases that make up the project, placed one on top of another, and following a flow of execution from top to bottom, like a waterfall.
The cascade development model originated in industry and construction, where changes afterwards are expensive and difficult to implement. When you are creating a material product, making changes to what is already built is much more difficult than in a computer program. In the software world, other development methodologies had not yet been implemented, so the cascade model that was used in other sectors was adapted.
The phases that make up the model are the following:
In this phase, an analysis of the client’s needs is made to determine the characteristics of the software to be developed, and everything that the system must do is specified without going into technical details. You have to be especially careful in this first phase, since in this model you can not add new requirements in the middle of the development process.
Therefore, this is the stage in which a description of the software requirements is carried out, and it is agreed between the client and the developer that the product should do. Having a specification of the requirements makes it possible to rigorously estimate the needs of the software before its design. In addition, it allows to have a base from which to estimate the cost of the product, the risks and the deadlines.
In the document in which the requirements are specified, a list of the agreed requirements is established. Developers must clearly understand the product they are going to develop. This is achieved by having a detailed list of the requirements, and with a fluid communication with the client until the end of the development time.
In this stage the internal structure of the software is described, and the relationships between the entities that compose it.
It decomposes and organizes the system into elements that can be elaborated separately, taking advantage of team development. The result is the SDD (Software Design Document), which contains the description of the global relational structure of the system and the specification of what each of its parts must do, as well as the way in which they combine with each other.
It is convenient to distinguish between high-level or architectural design and detailed design. The first of them aims to define the structure of the solution (once the analysis phase has described the problem) identifying large modules (sets of functions that will be associated) and their relationships. This defines the architecture of the chosen solution.
The second defines the algorithms used and the organization of the code to begin the implementation.
In this phase the specified requirements are programmed making use of the data structures designed in the previous phase. Programming is the process that leads from the formulation of a computing problem, to a program that is executed producing the necessary steps to solve said problem.
When programming, we have to carry out activities such as the analysis of conditions, the creation of algorithms, and the implementation of these in a specific programming language.
An algorithm is a set of well-defined and ordered instructions or rules that allow an activity to be carried out through successive steps.
As its name indicates, once the implementation phase is completed, it is verified that all system components work correctly and comply with the requirements.
The objective of the tests is to obtain information on the quality of the software, and they serve to: find defects or bugs, increase the quality of the software, refine the previously written code without fear of breaking it or introducing new bugs, etc.
Installation and Maintenance
Once all the functionalities of the software have been developed and it has been verified that they work correctly, the installation and maintenance phase begins. The application is installed in the system and it is checked that it works correctly in the environment in which it will be used.
From now on you have to make sure that the software works and you have to allocate resources to maintain it.
Software maintenance consists in modifying the product after it has been delivered to the customer, either to correct errors or to improve performance or features.
The purpose of this phase is to maintain the value of the software over time. This can be done by adding new requirements, correcting errors, renewing the visual aspect, improving efficiency or adding new technology. The maintenance period can last for years, which is why it is a key phase of the cascade model.
To carry out the maintenance phase correctly, it is necessary to draw up a plan in advance that prepares us for all the scenarios that may occur during this phase. To avoid future conflicts with the client, the plan must specify how users will request modifications or correction of errors, estimate the cost of modifying functionalities or correct errors, who will be responsible for maintenance, for how long Software will be supported, etc.
Advantages and Disadvantages of cascade development
The time spent designing the product in the early stages of the process can avoid problems that would be more costly when the project was already in the development phase.
The documentation is very exhaustive and if a new developer joins the team, you can understand the project by reading the documentation.
Being a very structured project, with well defined phases, it is easy to understand the project.
Ideal for stable projects, where the requirements are clear and will not change throughout the development process.
In many cases, customers do not know the requirements they will need before they see a first version of the software in operation. Then, many requirements will change and new ones will be added, which will mean replacing phases that have already been overcome and will cause an increase in costs.
The product is not shown to the client as it is being developed, but the result is seen once the entire process has been completed. This causes insecurity on the part of the client who wants to see the progress in the product
Designers may not take into account all the difficulties they will encounter when designing software, which will entail redesigning the project to solve the problem.
For long-term projects, this model can pose a problem by changing the user’s needs over time. If for example, we have a project that will last 5 years, it is very likely that the requirements need to adapt to the tastes and novelties of the market.
2. Spiral Model
While the waterfall methodology offers an orderly structure for software development, the demands of time reduced to the market make its serial steps inappropriate.
The spiral model in software development is a goal model of the software life cycle where the development effort is iterative, as soon as a development effort ends there starts another; In addition, in each execution of the development four main steps are followed:
Determine or set objectives. In this step, the specific objectives are defined to later identify the limitations of the process and the software system, in addition, a detailed management plan is designed and the risks are identified.
Risk analysis. In this step, a detailed analysis is carried out for each of the identified risks of the project, the steps to be followed to reduce the risks are defined and after the analysis of these risks, alternative strategies are planned.
Develop, verify and validate. In this third step, after the risk analysis, a paradigm for the development of the software system is chosen and developed.
Plan. This last step is where the project is reviewed and the decision is made whether to continue with a cycle subsequent to the spiral. If it is decided to continue, plans for the next phase of the project are developed.
With each iteration around the spiral, successive versions of the software are created, more and more complete and, in the end, the software system is already fully functional. The main difference between the spiral model and previous models (eg, waterfall, evolutionary, incremental, etc.) is the risk assessment. Risk is everything that can go wrong in a software development project. For example, if we want to use a programming language to develop an operating system, a possible risk is that usable compilers do not produce an efficient object code. Risks cause problems in the project, such as excess costs. Thus, the reduction of risks is a very important activity. A spiral model begins with the determination of both functional and performance objectives. Next, some possible ways of achieving these objectives are listed, identifying the sources of possible risks. Then we continue with the next step which is to solve these risks and carry out the development activities, to finish with the planning of the next cycle of the spiral.
Characteristics of the Spiral Model for The Development of software
It is considered as an evolutionary model since it combines the classic model with the design of prototypes. It contains a new stage that is risk analysis, not previously included.
This model is the one to develop software with different updated versions as it is done with modern PC programs.
Engineering can be developed through the classic life cycle or prototype construction.
This is the most realistic approach currently.
The spiral model is shared in several structural activities, also called task regions. There are six regions of tasks that are:
Communication with the client: this is a required task to establish communication between the developer and the client.
Planning: this task is necessary to apply it to be able to define resources, time and other information related to the project, that is, they are all requirements.
Risk analysis: this is one of the main tasks for which the spiral model is applied, it is required to evaluate the technical risks and other information related to the project.
Engineering: this is a necessary task since it is required to build one or more representations of the application.
Construction and adaptation: this task is required in the spiral model because it is necessary to build, test, install and provide support to the user.
Customer evaluation: this is also a main task, necessary to acquire the client’s reaction according to the evaluation of the software representations created during the engineering stage and the implementation stage created during the installation stage.
Advantages of the Spiral Model
It does not require a complete definition of the software requirements to be developed to begin its functionality.
In the completion of a product from the end of the first iteration it is very feasible to approve the requirements.
Suffering delays is less risky, because the conflicts presented early are checked and there is a way to correct them in time.
Disadvantages of the Spiral Model
There is a complication when assessing the risks.
Continuous participation by the client is required.
Time is lost when initially producing a complete specification of the requirements when the software is modified or improved.
Spiral Model Couplings
The new requirements of the system are defined in all possible details, this usually involves interviewing a certain number of users that will represent all external and internal users and other aspects of the existing system.
A preliminary prototype is created for the development of the new software based on a design made of the system that was built from the initial prototype. This is generally a scaled-down system, and represents an approximation of the characteristics of the final product.
A second software design is developed by a quad procedure:
Evaluation of the first prototype in terms of its strengths, weaknesses, and risks;
Define the requirements of the second prototype;
Planning and developing the second prototype;
Building and testing the second prototype.
At the client’s option, the completed project can be aborted if the risk is deemed too great. The risk factors could involve the excesses of development cost, miscalculation of merging costs, or any other factor that could, in the client’s judgment, result in a less than satisfactory end product.
The existing design is evaluated in a similar way as the previous design, and, if necessary, another prototype is developed according to the quad procedure described above.
The preceding steps are listed until the customer is satisfied knowing that the improved design represents the desired end product. In addition, the final system is built, based on the improved design. The final system is evaluated and tested with all of the law. General maintenance is performed on a continuous basis to prevent large-scale failures and to minimize wasted time.