Process Models

Table of Content:

Image source: https://www.synotive.com/blog/software-development-client-questionnaire

What is a software process model?

A simplified representation of the software development process is a software process model. The models provide information about the stages and sequence of a process. As a result, take the following as a depiction of the method's order of actions and, as a result, the sequence in which they're carried out.

The following will be defined by a model:

  • The duties that must be completed

  • Every task's input and output

  • Every task's pre- and post-conditions

  • Every task's flow and succession

A software process model's goal is to give direction for regulating and coordinating tasks so that the final result and objectives are met as quickly as possible.

Process models come in a variety of shapes and sizes to satisfy a variety of needs. These are referred to as SDLC models (Software Development Life Cycle models). The following are the most well-known and important SDLC models:

  • Waterfall model

  • Incremental model

  • RAD model

  • Agile model

  • Iterative model

  • Spiral model

What is Code and Fix?

When learning to code, the first phases entail a lot of experimenting with code development and debugging or error detection. One thinks of a logic, produces code, and then finds and solves all of the bugs/errors. When dealing with brief and simple situations, this is a popular technique. Surprisingly, this problem-solving strategy has also become a widely used paradigm in software development.

In many circumstances, code and fix (also known as cowboy coding) is considered the only or easiest software development technique, and it is the default (method). It's a two-step cyclic procedure that starts with coding and ends with fixing. Code and Fix is a paradigm that typically does not include substantial planning (sometimes a very rudimentary one), a definite strategy, or well-defined design stages. After some initial conversations, teams begin the coding process. Fixing usually occurs along the way so that the team may address any serious flaws or faults before continuing with the process.

Image source: https://www.tutorialride.com/software-testing/software-development-process-models.htm


Analyzing Code and Fix

For small and quick projects, Code and Fix could be very useful. It is frequently regarded as a time saver and may be a suitable model for low-cost projects. It's quite typical in software companies with a lot of entry-level developers who are interested in experimenting and observing things. Developers sometimes like this technique since it gives them complete control over the event process without requiring them to follow any formal directives from management.

Though it may appear that Code and Fix decreases development time, there is a significant danger of client dissatisfaction and failure due to a lack of a clear knowledge of requirements. Furthermore, when there is a large technical team, this model will fail due to continual communication issues. It is particularly dangerous to use Code and Fix for applications that may require future revisions, as new upgrades and updates may result in serious architectural concerns later in the process, necessitating the rewriting of huge portions of the appliance.

This technique can be regarded the least effective development methodology in many circumstances because it is not built for mid and large-scale software projects. Due of time constraints, software teams frequently employ Code and Fix. When a functional prototype must be created quickly and shown to project stakeholders. Code and Fix demonstrates immediate results, which makes this technique appealing to a number of engineers.

Code and Fix is widely used in many world projects, notably in startup products, in addition to being the most rudimentary software lifecycle model ever established. However, it is generally not seen as an ethical technique, and there are only a restricted number of instances in which Code and Fix can be used.

When to use Code and Fix:

  • For prototypes that don't require any planning ahead of time.

  • Small projects that don't require a lot of time to develop.

Image source: https://www.javatpoint.com/jira-waterfall-model

Waterfall Model

One of the first Process Models to be introduced was the Waterfall Model. Another name for it is a linear-sequential life cycle model. This model is relatively easy to comprehend and apply. In a waterfall model, each phase (or stage) must be finished before the next can begin, and the stages do not overlap.

The Waterfall model is thought to be the first SDLC approach used in software development.

In a linear sequential flow, the waterfall model depicts the software development process. This indicates that every new phase (or stage) of the development process can begin only after the previous one has finished. The phases in this paradigm, known as the waterfall model, do not overlap.


Phases in Waterfall model are −

  • Gathering and analyzing requirements: All requirements for the system to be developed or produced are captured in this section and documented in a requirement specification document.

  • System Design: Throughout the present phase, the requirement specifications document from the previous phase is researched and analyzed, and a system design is created as a result. The specification of hardware, system requirements, and overall system design are aided by this system architecture.

  • Implementation: The system is initially constructed in small programs known as units, which are then combined in the following phase using inputs from the system design. Each unit is created and put through Unit Testing, which involves checking its functionality.

  • Integration and Testing: After each unit has been tested, all of the units generated throughout the implementation stage are integrated into a system. After it has been incorporated, the complete system is tested for any defects or problems.

  • System deployment: The product is deployed in the client environment or launched to the market once functional and non-functional testing is completed.

  • Maintenance: Within the client environment, there are several issues that arise. Patches are published to address these vulnerabilities. Additionally, in order to improve the product, newer versions have been published. Maintenance is carried out in order to make these adjustments in the customer's environment.

All of these phases are interconnected, and progress appears to flow slowly downwards (like a cascade/waterfall) through them all. The next phase begins only after the preceding phase's established set of goals has been met and it has been signed off, hence the term "Waterfall Model." Phases do not overlap in this model.

Image source: https://www.guru99.com/what-is-rad-rapid-software-development-model-advantages-disadvantages.html

Rapid Application Development

Another software development process that emphasises quick prototyping over detailed planning is rapid application development. A prototype is a working model that mimics the functionality of a product component.

Functional modules are produced in parallel as prototypes under the RAD paradigm before being included into the complete product for faster delivery. It's easier to accommodate changes into the event process because preplanning isn't done in great detail.

In RAD initiatives, which follow an iterative and incremental model, small teams of domain experts, developers, client representatives, and other IT resources work gradually on their component or prototype.

Ensuring that the prototypes generated may be reused is the most critical part of this model's success.


RAD Model Design

The RAD technique divides the analysis, design, build, and test phases into multiple short iterative development cycles.

The RAD Model's many phases are listed below:-

Business Modelling

The business model for the product in development is built around the flow of information and the delivery of that information through multiple business channels. A comprehensive business analysis is conducted to determine where critical company information may be found, how it is frequently collected, how and when the information is processed, and what factors influence the successful flow of information.

Data Modelling

The data obtained during the Business Modeling phase is evaluated and analyzed to create collections of data items that are critical to the company's success. The attributes of each data set are recognized and defined. In regard to the business model, the relationship between these data elements is formed and defined in detail.

Process Modelling

The data object sets defined during the Data Modelling phase are translated to determine the business information flow required to achieve specified business objectives according to the business model. During this phase, the method model for any changes or enhancements to the info object sets is defined. There are descriptions of the processes for adding, deleting, retrieving, and changing a knowledge item.

Application Generation

Using automation technologies to convert process and data models into actual prototypes, the actual system is built and the coding is done.

Testing and Turnover

Because the prototypes are individually tested throughout each iteration, the overall testing time is minimized under the RAD approach. However, the information flow and, as a result, the interfaces between all of the components must be extensively verified with 100% coverage. The risk of serious issues is reduced because most of the programming components have previously been tested.



Incremental Model

During the software development cycle, the incremental model is a software development process that separates requirements into several independent modules. In this paradigm, each module goes through the requirements, design, implementation, and testing stages. After that, each subsequent version of the module adds features to the previous iteration. The method is continued until the system is fully functional.


Image source: https://www.javatpoint.com/software-engineering-incremental-model

Following are the various phases of incremental model:

1. Requirement analysis: The merchandise analysis expertise identifies the needs in the first step of the incremental model. As a result, the need analysis team is aware of the system's functional requirements. This step is crucial in the incremental software development process.

2. Design & Development: The planning of the system functionality and, as a result, the development process are effectively completed in this phase of the Incremental model of SDLC. The incremental model employs style and development phase when software creates new functionality.

3. Testing: In the incremental model, the testing step verifies the functionality of all current functions as well as new features. Various approaches are used to test the behavior of each task throughout the testing phase.

4. Implementation: The event system's coding phase is enabled by the implementation phase. It entails the final coding that is styled throughout the designing and development phase and then tested during the testing phase. Following the completion of this phase, the amount of working items is increased and updated all the way to the ultimate system product.

When should the Incremental Model be used?

  • When the demands are more stringent.

  • The development of a project takes a long period of time.

  • When the software crew isn't well-trained or skilled.

  • When the customer expects the product to be delivered quickly.

  • You might start by creating a list of requirements that are most important to you.

The Benefits of the Incremental Model

  • Errors are easily identifiable.

  • More adaptable and simple to test and debug.

  • Risk is easy to manage because it was handled at the iteration.

  • Important functionality is delivered to the client early.

The Incremental Model's Drawbacks

  • Good planning is required.

  • The total cost is quite significant.

  • Module interfaces must be clearly defined.


Image source: https://www.geeksforgeeks.org/software-engineering-evolutionary-model/

Evolutionary Models

The evolutionary model is a blend of two software development life cycle models: iterative and incremental. The activity under this approach is to distribute your system as part of a large release or in an incremental procedure over time. Compilation of basic requirements and architecture conceptualizing is required.

The evolutionary process models are listed below.

1. The prototyping model

2. The spiral model

3. Concurrent development model

Image source: https://www.tutorialride.com/software-testing/prototype-model.htm

The Prototyping model

  • The first or preliminary form from which other forms are reproduced or developed is referred to as a prototype.

  • The prototype model is basically a collection of general software goals.

  • It does not list all of the needs, such as specific input and output.

  • It's a software working paradigm with limited capabilities.

  • Working programs are quickly developed in this manner.


  • A spiral model could be used to model a risk-based process.

  • It's what's utilized to make software projects.

  • If a danger is discovered in the risk analysis, an alternate solution is given and incorporated in the spiral model.

  • It's a hybrid of the prototype and the sequential or waterfall paradigm.

  • All actions are completed in one cycle, although the output is little for large projects.


Image source: https://www.ques10.com/p/37145/concurrent-process-models-1/

The concurrent development model

  • Concurrent model is the name given to the concurrent development model.

  • Within the first iteration, the communication activity has concluded and has exited the awaiting changes state.

  • After completing its initial communication, the modelling work moved on to the underdevelopment stage.

  • If the customer specifies the change as part of the requirement, the modelling activity is moved from under development to awaiting turn.

  • The concurrent process model depicts activities transitioning from one state to another.


Iterative Model:

Iterative development is a software development method that divides the process of creating a large program into smaller pieces. Each phase, referred to as a "iteration," comprises the whole development process and includes steps such as planning, design, development, and testing. Unlike the Waterfall approach, the iterative process adds features one by one, delivering a working product at the end of each iteration and gradually increasing functionality from cycle to cycle.

Image source: https://commons.wikimedia.org/wiki/File:Iterative_development_model.svg

Advantages of the iterative development:

  • Iterative software development refers to the practice of producing products step by step, allowing for the detection and rectification of errors early on, preventing them from spreading to other processes.

  • You'll gain user feedback on how they see the products now and what they expect them to look like in the future if you use iterative development at the top of each stage. This gives you the opportunity to make any necessary changes and enhancements.

  • The iterative development strategy allows you to spend less time on documentation, which is often associated with the waterfall workflow, and more time on project design.

Iterative development's drawbacks include:

  • Although the iterative process as a whole is somewhat flexible, the iteration phases are rigorous and must be followed precisely.

  • Because not all of the wants are mentioned at the start of the project, unexpected changes may arise during iterative development.


SY D Group 19

Members:

Aditya Taware ROLL: 49 PRN: 12011064

Roopal Tatiwar ROLL: 48 PRN: 12011346

Aryaman Todkar ROLL: 57 PRN: 12010680

Rishikesh Unawane ROLL: 59 PRN: 12010340