Table of Contents
Software Life Cycle Model (SLCM) or Process Model
Software Life Cycle Model is the descriptive and pictorial representation of development of a software product; it includes the whole life cycle of software development from beginning to end.
In other words, a life cycle model maps all activities on a software product from beginning to end. Different life cycle models might plan development activities and phases in different ways. No matter which life cycle model you use, the essential activities remain the same regardless of the order in which they are performed. Multiple actions can be performed at any stage of the life cycle.
Various Software Development Models
Software development models imply that pre-defined software engineering models are utilized in developing software. Software development models include the waterfall model, prototyping model, incremental model, etc.,
- Dr. Winston W. Royce introduced the waterfall model in 1970.
- The waterfall model was originally developed in the construction and manufacturing industries. Because of the structured environments, design changes were more costly earlier in the development process.
- The waterfall model was first used for software development. There were no alternatives to knowledge-based creative work.
Waterfall model: It means the development process will be followed step by step; once the step is passed, then only you can proceed to the next step.
In other words, in the waterfall model, the whole process is divided into separate phases meaning when water is falling then water cannot come back. As the same applies in this model, when any phase is complete then we cannot come back to the previous phase.
Waterfall model process includes:
- Simple to understand and easy to use
- Easy to manage
- Steps are processed & completed one by one
- Requirements are very well understood
- Clearly defined steps
- No final software outcome is present until the late use of life cycle
- It involves the high amount of risk
- Not good for complex & object oriented program
- Poor model for large and ongoing projects
Modified or Iterative Waterfall Model
Iterative Waterfall model: Iterative Waterfall model is the updated version of the Classical Waterfall model, which is the same as the Classical Waterfall model except for one feature that introduces the feedback paths from every phase to its preceding steps.
If errors are discovered at an earlier stage, they can be corrected by feedback pathways, correcting mistakes made by programmers during a specific phase. Feedback paths permit the step to be altered when errors are made, and the changes are then carried over to the subsequent phases. There is no feedback route to the feasibility study stage because after a decision has been completed, it’s possible to continue the project in a single step.
It is beneficial to spot mistakes at the exact time when they are made. This will reduce the effort and time needed to fix the errors.
When to use?
- If the requirements are clearly stated and are easy to comprehend.
- If the software program is huge.
- In the event of a requirement for future changes.
Iterative Waterfall Model Process
- The Iterative waterfall model is easy to comprehend and apply. This is why it’s one of the most commonly utilized modeling software for development.
- In the waterfall model, there are no feedback paths, which means there is no mechanism to allow error correction. However, in the Iterative waterfall model, the feedback paths from one phase to the preceding phase can be used to correct the mistakes that have been made, and these modifications are reflected in subsequent phases.
- It is incredibly cost-effective to alter the requirements or plan in the model. Furthermore, it is designed for agile organizations.
- This way, there is less time spent on documents, and the team can devote more time to developing and designing.
- The principal drawback of the iterative waterfall model is that the entire set of requirements must be clearly defined before beginning the stage of development. Users can change their conditions over time, but the iterative waterfall model is designed in a way that only allows for room to accommodate changes submitted before the beginning of the development phase.
- In the iterative waterfall model, the complete software is created and tested before its delivery to the client. There is no need for any intermediary delivery. Therefore, the customers must wait a long time to receive the software.
- Projects can be exposed to various kinds of risks. However, the iterative waterfall model is not risk-free. The iterative waterfall model does not have a way to manage risk.
- The interaction with customers begins at the beginning of the project, at the time of gathering requirements and after the point of completion of delivery of the software. The lack of customer interaction can cause issues since the final software might not meet the customer’s requirements.
Prototype model: It builds the demo version software of original software with some limited functions. It is being built to get the feedback from the user in knowing how they are experiencing while using the demo cum original software.
In other words, A prototype is a working software model with limited functionality.
Prototype Model does not include the complete software development. Instead, we first create a prototype. This allows us to incorporate the most useful functions into the product. The software is then handed to the customer. They will test the product and make any necessary adjustments. We will remove any problems from the product, or create a new version of the prototype if the customer is unhappy with the product.
When to use?
- Prototype Model: When the system is going to need to interact with many users, a prototyping model should be used.
- Uncertain Requirements – If requirements are not clearly understood
- Complex and large systems
- Illustration of the User Interface
- Uncertain Solutions
Steps of Prototype model
Types of Prototype
Rapid Throwaway Prototype – It is based on the user’s first-ever requirements or feedback. As the user says to make changes to the Prototype, developers discard the existing Prototype, build a new one from scratch, and keep building until it meets the customer’s requirements.
Evolutionary Prototype – It doesn’t require discarding the existing Prototype and making a new one; instead, the developer changes the current Prototype according to the user’s feedback and keeps updating the Prototype until the customer is satisfied.
- Users are actively involved in the development
- More accurate user requirements are obtained.
- Errors can be detected much earlier
- Quicker customer feedback provides a better idea of customer needs.
- Missing Functionality can be identified quickly.
- If the customer is unsatisfied with a prototype, then we can develop a new one.
- If the user is unsatisfied with the design, a new prototype is developed. This cycle continues until a final prototype is created. Therefore, the model is costly and time-consuming.
- After viewing the prototype in its early stages, people who use it may request the system to be released soon.
- If the end-user isn’t satisfied with the prototype, the user may not be interested in the idea.
Incremental model: It is the process of developing the software step by step after breaking the cycle into different modules. It uses the waterfall model to develop the software and increment each module with the previous one.
Points to be remembered:
- The development team first creates the core module of the software project; following that, additional modules are developed, each one at a time and then each module grows in line with the core module, and so on.
- A core module is a term used to describe how developers design the top priority requirements. Therefore, when the Core module has been created, it’s handed over to the client so that the customer can utilize it and provide us with feedback on the developed program.
- Then, additional modules are created individually, then added until they are a core module and delivered to the client at the end of each increment.
Then, the customers’ needs are considered before the beginning of the project. SRS documents are developed in the initial phase; we design and update software module-by-module according to the customer’s specifications.
When to use?
- Know the all requirements of the customer
- Clear understanding of each modules
- When the product is to deliver early
- Project is big and time consuming
- Big goal with high risk involved
- Use of new technology with experienced team member
All the requirements of the users are collected at the beginning stage, and SRS documents are created in the starting phase, after that developers develop and increment software step-by-step according to the user’s requirements.
- It is easy to break down tasks due to the divide-and-conquer strategies used.
- Using it is a good idea when the requirements are clear and well-defined.
- It is recommended to use for projects with long development time frames.
- It creates functional software quickly and in the early stages of the development cycle of the software.
- It’s more flexible and cost-effective to alter requirements and scope.
- It requires a good planning.
- Issues could arise due to the system’s architecture because not all requirements are gathered upfront for the entire life-cycle of the software.
- Each iteration is a separate phase and does not cross the other.
- Resolving a problem in one unit is a matter of correcting across all units and takes a lot of time.
What is Spiral Model?
The spiral model is an evolution software model that blends the most effective features of the waterfall model, the prototype model, and the incremental model. It was first presented in 1988 by Barry Boehm in his 1988 article.
The risk-driven nature of the software development model means it is more geared towards the highest risk in software development and strives to limit the risk as much as possible. So this model’s primary focus is risk-avoidance-driven rather than document-driven, code-driven, or release driven.
The primary purpose of this model of the spiral is to concentrate on the riskiest features. Find out what risks could be involved in the process of developing software. Once you have identified the potential risks, you must analyze them and consider alternative strategies to satisfy the win requirements. Therefore, the primary goal of this method is to minimize the risk involved in the process by looking for ways to minimize the risk.
The risks associated with this model may be cost-related and schedule-related, system performance, safety, user interface organizational impacts, etc.
Each spiral loop symbolizes the iterative waterfall model. The model uses prototyping to reduce the risk. Before developing the final product, this model is based on an early prototype. This reduces the risks and provides great feedback from the customers.
The term “spiral” is because the software program moves across each phase several times through iterations, a process known as a spiral. Every cycle (loop) within the spiral has four distinct stages (quadrants).
When to use?
- Projects where frequent releases are required;
- Projects that require changes, which may be needed at any time;
- Long-term plans which aren’t feasible because of changing priorities in the economy;
- Medium to high risk projects;
- Projects where risk and cost analysis is crucial;
Steps in Spiral Loop
- It is needed to identify the objectives.
- Check the risks present with these objectives.
- Total analysis of each project risk identified in the previous.
- After analysis managed the risks for reducing them.
- After managing the risk proceed for the next level i.e. development and validation of the product.
- Taking feedback from the customer and planning for the next iteration.
- Incrementally changes and completes the version of the software as per the customer requirements.
- Software is created during the early stages of the software cycle.
- Risk management is one of the significant benefits of the Spiral model. It is also the most effective development model because of every stage’s risk analysis and management.
- Flexibility in the requirements. This model can easily alter requirements in later stages and be integrated accurately. Additionally, additional functionality is possible to add in the future.
- It is suitable for complex and large-scale projects.
- Affirmation of the quality and control of documentation.
- It’s not a good choice for small-scale projects because it’s costly.
- It is more complicated in comparison to other SDLC models.
- Much trust is placed in Risk Analysis, requiring highly specific knowledge.
- A challenge in managing time. Because the number of phases is not known at the beginning of the process, time estimation can be very challenging.
- Spiral can continue indefinitely.
Component Model: It is a reuse based development process like defining, implementation etc. The concept of this model came from component-based development (CBD), which is also known as component-based software engineering (CBSE).
It focuses on the design and development of computer-based systems with the use of reusable software components.
E.g., using a call-to-action development process from previous software to new software process.
CBSE Framework Activities
This process assures that the system’s architecture determines the requirements of components to be reused component.
This assures that the architecture establishes the design requirements for all components and defines how they connect.
This process ensures that the Architectural design of the system is integrated with the components of the software and creates an operational system.
This is a way to ensure the maintenance of components that are reused. Sometimes, updates are difficult because of the addition of an outside Party.
Agile Software Model
Agile Software Model: It is a process in which the main priority is to reduce the software development time taken in traditional waterfall model.
In other words, Agile software process main focus is on rapid development of software.
Agile Process Flow
Initial Concept – Projects are established based on customer priority.
Examine – developers are selected, funds are ready, and discussed about initial environments and requirements.
Construct – The development team starts work to ready the software based on iteration requirements and feedback of the customer.
Release – At first Quality Assurance testing is established, conducts internal training and external training for customers, ready the documentation, and then final release of the iteration into production.
Development – Ongoing support of the software
Completion – End of the ongoing activities, likes including customer feedback and migration of the software.
Issues Agile Resolve
Discussing different software development models can help you understand the software design model’s role in developing software. It will also clarify the reasons and which model you should use to create the software. In this article, we’ve examined the advantages and disadvantages of relying on a model. It will shed light on their usage in software development and help you choose the best model suitable for your software development needs.
We hope it has eliminated all the complexities of the various software development models and could have provided you with an easy path to select which one to choose at the stage of software development.
If you find anything incorrect in the above-discussed topic and have further questions, please comment below.