DIFFERENCE BETWEEN PROGRAM AND SOFTWARE

Program :
1. A computer program is a set of instructions that is used as a process of creating a software
program by using programming language
2. Programs do not have further categorization.
3. A program does not have a user interface
4. Programs are smaller in size, and their size exists between Kilobyte (Kb) to a megabyte (Mb).
5. A program takes less time to be developed.
6. A program includes fewer features and limited functionalities
7. The development approach of a program is unorganized, unplanned, and unprocedural.
8. There is a lack of documentation in the program.
9. Examples of the program are - video games, malware, and many more.

SOTWARE:
1. Software is a set of programs that enables the hardware to perform a specific task.
2. The software can be of three types: system software, application software, and programming
software.
3. Every software has a user interface that may be in graphical format or in the form of a
command prompt.
4. Every software has a user interface that may be in graphical format or in the form of a
command prompt.
5. software requires more time to be developed.
6. It has more features and functionalities
7. The development approach of software is well planned, organized, and systematic
8. Softwares are properly documented.
9. Examples of software are - Adobe Photoshop, Adobe Reader, Google Chrome, and many
more.

Software characteristics
Software is defined as collection of data, programs, procedures, associated documentaion
and rules. which does not have any mass, volume and colour. software does not wear out,get
tired or degrade over a long period of time.

These components are described below:

• Functionality:
It refers to the suitability, accuracy, interoperability, compliance, security of software
which is measured as degree of performance of the software against its intended
purpose.
• Reliability:
Refers to the recoverability, fault tolerance, maturity of software, which is basically
a capability of the software that provide required functionality under the given
situations.

• Efficiency:
It is the ability of the software to use resources of system in the most effective and
efficient manner. Software must make effective use of syetm storage and
execute command as per required timing.

• Usability:
It is the extent to which the software can be utilized with ease and the amount of
effort or time required to learn how to use the software.
• Maintainability:
It is the ease with which the modifications can be made in a software to extend or
enhance its functionality, improve its performance, or resolve bugs.

• Portability:
It is the ease with which software developers can relaunch software from one platform
to another, without (or with minimum) changes. In simple terms, software must be
made in way that it should be platform independent.

Evolution of software engineering as a

discipline.
Software Evolution is a term which refers to the process of developing software initially, then
timely updating it for various reasons, i.e., to add new features or to remove obsolete
functionalities etc. The evolution process includes fundamental activities of change analysis,
release planning, system implementation and releasing a system to customers. The cost and
 impact of these changes are accessed to see how much system is affected by the change and
how much it might cost to implement the change. If the proposed changes are accepted, a
new release of the software system is planned. During release planning, all the proposed
changes (fault repair, adaptation, and new functionality) are considered ..A design is then
made on which changes to implement in the next version of the system. The process of
change implementation is an iteration of the development process where the revisions to
the system are designed, implemented and tested.
The necessity of Software evolution: Software evaluation is necessary just because of the
following reasons:

a) Change in requirement with time: With the passes of time, the organization’s needs and
modus Operandi of working could substantially be changed so in this frequently changing
time the tools(software) that they are using need to change for maximizing the performance.

b) Environment change: As the working environment changes the things(tools) that enable
us to work in that environment also changes proportionally same happens in the software
world as the working environment changes then, the organizations need reintroduction of old
software with updated features and functionality to adapt the new environment.

c) Errors and bugs: As the age of the deployed software within an organization increases
their preciseness or impeccability decrease and the efficiency to bear the increasing
complexity workload also continually degrades. So, in that case, it becomes necessary to
avoid use of obsolete and aged software. All such obsolete Softwares need to undergo the
evolution process in order to become robust as per the workload complexity of the current
environment.

d) Security risks: Using outdated software within an organization may lead you to at the
verge of various software-based cyberattacks and could expose your confidential data
illegally associated with the software that is in use. So, it becomes necessary to avoid such
security breaches through regular assessment of the security patches/modules are used within
the software. If the software isn’t robust enough to bear the current occurring Cyber attacks
so it must be changed (updated).

e) For having new functionality and features: In order to increase the performance and fast
data processing and other functionalities, an organization need to continuously evolute the
software throughout its life cycle so that stakeholders & clients of the product could work
efficiently.

Laws used for Software Evolution:

 1. Law of continuing change:
This law states that any software system that represents some real-world reality
undergoes continuous change or become progressively less useful in that
environment.
2. Law of increasing complexity:
As an evolving program changes, its structure becomes more complex unless effective
efforts are made to avoid this phenomenon.
3. Law of conservation of organization stability:
Over the lifetime of a program, the rate of development of that program is
approximately constant and independent of the resource devoted to system
development.
4. Law of conservation of familiarity:
This law states that during the active lifetime of the program, changes made in the
successive release are almost constant.

SOFTWARE CRISIS

Software Crisis is a term used in computer science for the difficulty of writing useful and
efficient computer programs in the required time. The software crisis was due to using the
same workforce, same methods, same tools even though rapidly increasing in software
demand, the complexity of software, and software challenges. With the increase in the
complexity of software, many software problems arise because existing methods were
insufficient. If we will use the same workforce, same methods, and same tools after the fast
increase in software demand, software complexity, and software challenges, then there arise
some problems like software budget problems, software efficiency problems, software quality
problems, software managing and delivering problem, etc. This condition is called a software
crisis

Causes of Software Crisis:

• The cost of owning and maintaining software was as expensive as developing the
software
• At that time Projects were running over-time
• At that time Software was very inefficient
• The quality of the software was low quality
• Software often did not meet user requirements
• The average software project overshoots its schedule by half
• At that time Software was never delivered
• Non-optimal resource utilization.
• Difficult to alter, debug, and enhance.
 • The software complexity is harder to change.

factors are contributing to the software crisis.

• Poor project management.

• Lack of adequate training in software engineering.
• Less skilled project members.
• Low productivity improvements.

Solution of Software Crisis: There is no single solution to the crisis. One possible
solution to a software crisis is Software Engineering because software engineering is a
systematic, disciplined, and quantifiable approach. For preventing software crises, there are
some guidelines:

• Reduction in software over budget.

• The quality of software must be high.
• Less time is needed for a software project.
• Experienced and skilled people working over the software project.
• Software must be delivered.
• Software must meet user requirements.

Dissection of IEEE definition of software engineering.

IEEE defines software engineering as:

(1) The application of a systematic , disciplined, quantifiable approach to the development,

operation and maintenance of software; that is, the application of engineering to software.

(2) The study of approaches as in the above statement.

Fritz Bauer, a German computer scientist, defines software engineering as:

Software engineering is the establishment and use of sound engineering principles in order to
obtain economically software that is reliable and work efficiently on real machines.

SOFTWARE PRODUCT
Software Products are nothing but software systems delivered to the customer with the
documentation that describes how to install and use the system. In certain cases, software
products may be part of system products where hardware, as well as software, is delivered to
a customer. Software products are produced with the help of the software process. The
software process is a way in which we produce software.

Types of software products:

Software products fall into two broad categories:

1. Generic products:
Generic products are stand-alone systems that are developed by a production unit and
sold on the open market to any customer who is able to buy them.
 2. Customized Products:
Customized products are the systems that are commissioned by a particular customer.
Some contractor develops the software for that customer.

Essential characteristics of Well-Engineered Software Product:

A well-engineered software product should possess the following essential characteristics:

• Efficiency:
The software should not make wasteful use of system resources such as memory and
processor cycles.
• Maintainability:
It should be possible to evolve the software to meet the changing requirements of
customers.
• Dependability:
It is the flexibility of the software that ought to not cause any physical or economic
injury within the event of system failure. It includes a range of characteristics such as
reliability, security, and safety.
• In time:
Software should be developed well in time.
• Within Budget:
The software development costs should not overrun and it should be within the
budgetary limit.
• Functionality:
The software system should exhibit the proper functionality, i.e. it should perform all
the functions it is supposed to perform.
• Adaptability:
The software system should have the ability to get adapted to a reasonable extent with
the changing requirements.

Attributes

software Quality Attributes are features that facilitate the

measurement of a software product’s performance by
Software Testing professionals. They play a vital role in
helping software architects guarantee that a software
application will perform as expected based on the
specifications provided by the client. Though there are
numerous software quality attributes, we will be focusing on
the most important ones that we have mentioned below:

1.functionality: This attribute determines the conformity of a

software-driven system with the defined requirements and
specifications.
Most Software Testing professionals view this attribute as the
most important one as an application fails on the most basic
level if it doesn’t function as expected. That is why we always
advocate performing tests that assess the desired functionality
of a system during the early stages of software testing.

2. Performance: it is a very important trait for every software to

have in this fast-paced world. It can be understood as the ability
of a software-driven system to conform to timing requirements.
From a testing point of view, it implies that QA testers must
check whether the system responds to various events within
defined time limits. These events may occur in the form of clock
events, process interruptions, messages, requests from different
users, and so on.

3. Reliability: Reliability is to check if the application or the

testing product with different combinations to see if it
withstands its nature and produces the expected results. By
different combinations, we mean testing it in different browsers,
operating systems, environments, and so on.

4. Testability: In leading software company this is the most

important attribute of software product. It indicates how well
the application allows software testers to perform tests in line
with the predefined criteria. In addition to that, this software
quality attribute also assesses the ease with which QA engineers
can develop test criteria for a said system and its various
components . QA professionals can assess the testability of a
system by using various techniques such as encapsulation,
interfaces, patterns, low coupling, and more.

5.Avaliability : this software quality attribute indicates whether

an application will execute the tasks when they are assigned. It
can be defined as a ratio of the system’s available time to the
required time it is expected to perform. Top-notch availability
indicates that a software-driven system will recover from
operational failures or scheduled maintenance periods without
exceeding a specific time value.

6.Interoperability : Software-driven systems could be required

to communicate and act in tandem with different systems to
perform certain tasks. Interoperability is the ability of the system
to interact with other systems to exchange the required
information via certain interfaces. So, Software Quality
Assurance engineers must examine the interoperability of a
system in terms of both syntactic and semantic interoperability.

7.security : We have added security to our list of the most

important software quality attributes as it has lately been the
need of the hour. The number of cyber-attacks has been on the
rise and users have started prioritizing a product’s safety. So the
security attribute measures the ability of a system to protect
and block malicious or unauthorized actions that could
negatively impact the user or destroy the system.Security also
includes authorization and authentication techniques,
protection against network attacks, data encryption, and other
risks. It is imperative for Software Testing Companies and
professionals to regularly conduct updated security checks on
systems.

8:flexibility : If keeping up with the security threats is a key

aspect, so is the system’s ability to keep up with the upcoming
trends and requirements. And for that, the system should be
flexible enough or should be able to modify accordingly. For
example, let’s say you’re working on a web application that was
developed when Windows 8 was launched. As the OS gets
upgraded, the application should be flexible enough to support
future versions such as Windows 10 & 11.

10.Efficiency : Because an inefficient application might work

well only when it consumes excessive resources that slow down
other applications or the system on the whole. In addition to
checking how long it takes to complete a process, it is also
important to check the level of system resource usage. For
example, if the system uses the entire CPU power and memory
for a single application. It can be considered to be inefficient as
it pulls down the performance of the entire system from the
user’s perspective.

11.usability: Though all software-driven systems are designed

with ease of use in mind, not all achieve this goal. And the
software quality attribute of usability denotes the ease with
which users are able to execute tasks on the system. It also
indicates the level of user support provided by the system.

In addition to general usability, Software Quality Assurance

engineers must also test if the software is accessible to people
with different types of abilities. Usability plays a critical role in a
product’s success and the most well-known principle to achieve
it is KISS (Keep It Simple Stupid).

SOFTWARE PROCESS – FRAMEWORK

Software Process Framework is an abstraction of the software

development process. It details the steps and chronological order
of a process. Since it serves as a foundation for them, it is utilized
in most applications. Task sets, umbrella activities, and process
framework activities all define the characteristics of the software
development process.
Software process includes:
• Tasks – focus on a small, specific objective.
• Action – set of tasks that produce a major work product.
• Activities – group of related tasks and actions for a major
objective.

Process Framework Activities:

The process framework is required for representing common process

activities. Five framework activities are described in a process framework for
software engineering. Communication, planning, modeling, construction, and
deployment are all examples of framework activities. Each engineering action
defined by a framework activity comprises a list of needed work outputs,
project milestones, and software quality assurance (SQA) points.
• Communication: By communication, customer requirement
gathering is done. Communication with consumers and
stakeholders to determine the system’s objectives and the
software’s requirements.
• Planning: Establish engineering work plan, describes technical
risk, lists resources requirements, work produced and defines work
schedule.
• Modeling: Architectural models and design to better understand
the problem and for work towards the best solution. The software
model is prepared by
a. Analysis of requirements.
b. Design
• Construction: Creating code, testing the system, fixing bugs, and
confirming that all criteria are met. The software design is mapped
into a code by:
a. Testing .
b. Code generation .

• Deployment: In this activity, a complete or non-complete product

or software is represented to the customers to evaluate and give
 feedback. On the basis of their feedback, we modify the product for
the supply of better products.
The Software Process Model
A software process model is a specified definition of a software
process, which is presented from a particular perspective. Models, by
their nature, are a simplification, so a software process model is an
abstraction of the actual process, which is being described. Process
models may contain activities, which are part of the software process,
software product, and the roles of people involved in software
engineering. Some examples of the types of software process models
that may be produced are :

1.WATERFALL MODEL:

Winston Royce introduced the Waterfall Model in 1970.This model

has five phases: Requirements analysis and specification, design,
implementation, and unit testing, integration and system testing, and
operation and maintenance. The steps always follow in this order and
do not overlap. The developer must complete every phase before the
next phase begins. This model is named "Waterfall Model", because
its diagrammatic representation resembles a cascade of waterfalls.
1.Requirements analysis and specification phase: The aim of this
phase is to understand the exact requirements of the customer and
to document them properly. Both the customer and the software
developer work together so as to document all the functions,
performance, and interfacing requirement of the software. It
describes the "what" of the system to be produced and not "how."In
this phase, a large document called Software Requirement
Specification (SRS) document is created which contained a detailed
description of what the system will do in the common language.

2.Design Phase: This phase aims to transform the requirements

gathered in the SRS into a suitable form which permits further coding
in a programming language. It defines the overall software
architecture together with high level and detailed design. All this
work is documented as a Software Design Document (SDD).

3. Implementation and unit testing: During this phase, design is

implemented. If the SDD is complete, the implementation or coding
phase proceeds smoothly, because all the information needed by
software developers is contained in the SDD.

• During testing, the code is thoroughly examined and modified.

Small modules are tested in isolation initially. After that these
modules are tested by writing some overhead code to check
the interaction between these modules and the flow of
intermediate output.

4. Integration and System Testing: This phase is highly crucial as

the quality of the end product is determined by the effectiveness of
the testing carried out. The better output will lead to satisfied
customers, lower maintenance costs, and accurate results. Unit
testing determines the efficiency of individual modules. However, in
this phase, the modules are tested for their interactions with each
other and with the system.
5. Operation and maintenance phase: Maintenance is the task
performed by every user once the software has been delivered to the
customer, installed, and operational.

APPLICATIONS:

o When the requirements are constant and not changed

regularly.
o A project is short
o The situation is calm
o Where the tools and technology used is consistent and is not
changing
o When resources are well prepared and are available to use .

2.RAD (Rapid Application Development)

Model:
RAD is a linear sequential software development process model that
emphasizes a concise development cycle using an element based
construction approach. If the requirements are well understood and
described, and the project scope is a constraint, the RAD process
enables a development team to create a fully functional system
within a concise time period. There are different phases in RAD:

1.Business Modelling: The information flow among business

functions is defined by answering questions like what data drives the
business process, what data is generated, who generates it, where
does the information go, who process it and so on.

2. Data Modelling: The data collected from business modeling is

refined into a set of data objects (entities) that are needed to support
the business. The attributes (character of each entity) are identified,
and the relation between these data objects (entities) is defined.
3. Process Modelling: The information object defined in the data
modeling phase are transformed to achieve the data flow necessary
to implement a business function. Processing descriptions are
created for adding, modifying, deleting, or retrieving a data object.

4. Application Generation: Automated tools are used to facilitate

construction of the software; even they use the 4th GL techniques.

5. Testing & Turnover: Many of the programming components have

already been tested since RAD emphasis reuse. This reduces the
overall testing time. But the new part must be tested, and all
interfaces must be fully exercised.

APPLICATIONS

o When the system should need to create the project that

modularizes in a short span time (2-3 months).
o When the requirements are well-known.
o When the technical risk is limited.
o When there's a necessity to make a system, which modularized
in 2-3 months of period.
o It should be used only if the budget allows the use of automatic
code generating tools.

3.SPIRAL MODEL:
The spiral model, initially proposed by Boehm, is an evolutionary
software process model that couples the iterative feature of
prototyping with the controlled and systematic aspects of the linear
sequential model. It implements the potential for rapid development
of new versions of the software. Using the spiral model, the software
is developed in a series of incremental releases. During the early
iterations, the additional release may be a paper model or prototype.
During later iterations, more and more complete versions of the
engineered system are produced.
Each cycle in the spiral is divided into four parts:

Objective setting: Each cycle in the spiral starts with the

identification of purpose for that cycle, the various alternatives that
are possible for achieving the targets, and the constraints that exists.

Risk Assessment and reduction: The next phase in the cycle is to

calculate these various alternatives based on the goals and
constraints. The focus of evaluation in this stage is located on the risk
perception for the project.

Development and validation: The next phase is to develop

strategies that resolve uncertainties and risks. This process may
include activities such as benchmarking, simulation, and prototyping.

Planning: Finally, the next step is planned. The project is reviewed,

and a choice made whether to continue with a further period of the
spiral. If it is determined to keep, plans are drawn up for the next step
of the project.

The development phase depends on the remaining risks. For

example, if performance or user-interface risks are treated more
essential than the program development risks, the next phase may
be an evolutionary development that includes developing a more
detailed prototype for solving the risks.

The risk-driven feature of the spiral model allows it to accommodate

any mixture of a specification-oriented, prototype-oriented,
simulation-oriented, or another type of approach. An essential
element of the model is that each period of the spiral is completed
by a review that includes all the products developed during that cycle,
including plans for the next cycle. The spiral model works for
development as well as enhancement projects.

When to use Spiral Model?

o When deliverance is required to be frequent.
 o When the project is large
o When requirements are unclear and complex
o When changes may require at any time
o Large and high budget projects.

3.Incremental Model: Incremental Model is a process of

software development where requirements divided into multiple
standalone modules(Standalone Module means a software program
or combination of software programs ) of the software development
cycle. In this model, each module goes through the requirements,
design, implementation and testing phases. Every subsequent release
of the module adds function to the previous release. The process
continues until the complete system achieved. There are different
phases in this model which are :

1. Requirement analysis: In the first phase of the incremental model,

the product analysis expertise identifies the requirements. And the
system functional requirements are understood by the requirement
analysis team. To develop the software under the incremental model,
this phase performs a crucial role.
2. Design & Development: In this phase of the Incremental model
of SDLC, the design of the system functionality and the development
method are finished with success. When software develops new
practicality, the incremental model uses style and development
phase.

3. Testing: In the incremental model, the testing phase checks the

performance of each existing function as well as additional
functionality. In the testing phase, the various methods are used to
test the behavior of each task.

4. Implementation: Implementation phase enables the coding

phase of the development system. It involves the final coding that
design in the designing and development phase and tests the
functionality in the testing phase. After completion of this phase, the
number of the product working is enhanced and upgraded up to the
final system product.

USES:

o When the requirements are superior.

o A project has a lengthy development schedule.
o When Software team are not very well skilled or trained.
o When the customer demands a quick release of the product.
o You can develop prioritized requirements first.
4.Evolutionary model :
It is a combination of Iterative and Incremental model of software
development life cycle. Delivering your system in a big bang
release, delivering it in incremental process over time is the action
done in this model. Some initial requirements and architecture
envisioning need to be done. It is better for software products that
have their feature sets redefined during development because of
user feedback and other factors. The Evolutionary development
model divides the development cycle into smaller, incremental
waterfall models in which users are able to get access to the
product at the end of each cycle. Feedback is provided by the
users on the product for the planning stage of the next cycle and
the development team responds, often by changing the product,
plan or process. Therefore, the software product evolves with
time. All the models have the disadvantage that the duration of
time from start of the project to the delivery time of a solution is
very high. Evolutionary model solves this problem in a different
approach.
Evolutionary model suggests breaking down of work into smaller
chunks, prioritizing them and then delivering those chunks to the
customer one by one. The number of chunks is huge and is the
number of deliveries made to the customer. The main advantage
is that the customer’s confidence increases as he constantly gets
quantifiable goods or services from the beginning of the project to
verify and validate his requirements. The model allows for
changing requirements as well as all work is broken down into
maintainable work chunks

5.Prototyping:
It is defined as the process of developing a working replication of a
product or system that has to be engineered. It offers a small-scale
facsimile of the end product and is used for obtaining customer
feedback. The Prototyping concept is described below:
The Prototyping Model is one of the most popularly used Software
Development Life Cycle Models (SDLC models). This model is used when the
customers do not know the exact project requirements beforehand. In this
model, a prototype of the end product is first developed, tested, and refined
as per customer feedback repeatedly till a final acceptable prototype is
achieved which forms the basis for developing the final product. In this
process model, the system is partially implemented before or during the
analysis phase thereby giving the customers an opportunity to see the
product early in the life cycle. The process starts by interviewing the
customers and developing the incomplete high-level paper model. This
document is used to build the initial prototype supporting only the basic
functionality as desired by the customer. Once the customer figures out the
problems, the prototype is further refined to eliminate them. The process
continues until the user approves the prototype and finds the working model
to be satisfactory.
Steps Prototyping Model
Step 1: Requirement Gathering and Analysis: This is the initial step in
designing a prototype model. In this phase, users are asked about what they
expect or what they want from the system.
Step 2: Quick Design: This is the second step in Prototyping Model. This
model covers the basic design of the requirement through which a quick
overview can be easily described.
Step 3: Build a Prototype: This step helps in building an actual prototype
from the knowledge gained from prototype design.
Step 4: Initial User Evaluation: This step describes the preliminary testing
where the investigation of the performance model occurs, as the customer
will tell the strength and weaknesses of the design, which was sent to the
developer.
Step 5: Refining Prototype: If any feedback is given by the user, then
improving the client’s response to feedback and suggestions, the final system
is approved.
Step 6: Implement Product and Maintain: This is the final step in the phase
of the Prototyping Model where the final system is tested and distributed to
production, here program is run regularly to prevent failures.
For more, you can refer to Software Prototyping Model Phases.
 Prototyping Models

Types of Prototyping Models

There are four types of Prototyping Models, which are described below.
• Rapid Throwaway Prototyping
• Evolutionary Prototyping
• Incremental Prototyping
• Extreme Prototyping
1. Rapid Throwaway Prototyping
This technique offers a useful method of exploring ideas and getting
customer feedback for each of them. In this method, a developed prototype
need not necessarily be a part of the ultimately accepted prototype. Customer
feedback helps in preventing unnecessary design faults and hence, the final
prototype developed is of better quality.
2. Evolutionary Prototyping
In this method, the prototype developed initially is incrementally refined on
the basis of customer feedback till it finally gets accepted. In comparison to
Rapid Throwaway Prototyping, it offers a better approach that saves time as
well as effort. This is because developing a prototype from scratch for every
iteration of the process can sometimes be very frustrating for the developers.

3. Incremental Prototyping
In this type of incremental Prototyping, the final expected product is broken
into different small pieces of prototypes and developed individually. In the
end, when all individual pieces are properly developed, then the different
prototypes are collectively merged into a single final product in their
predefined order. It’s a very efficient approach that reduces the complexity of
the development process, where the goal is divided into sub-parts and each
sub-part is developed individually. The time interval between the project’s
beginning and final delivery is substantially reduced because all parts of the
system are prototyped and tested simultaneously. Of course, there might be
the possibility that the pieces just do not fit together due to some lack of ness
in the development phase – this can only be fixed by careful and complete
plotting of the entire system before prototyping starts.

4. Extreme Prototyping
This method is mainly used for web development. It consists of three
sequential independent phases:
1. In this phase, a basic prototype with all the existing static pages is
presented in HTML format.
2. In the 2nd phase, Functional screens are made with a simulated data
process using a prototype services layer.
3. This is the final step where all the services are implemented and
associated with the final prototype.
This Extreme Prototyping method makes the project cycling and delivery
robust and fast and keeps the entire developer team focused and centralized
on product deliveries rather than discovering all possible needs and
specifications and adding unnecessitated features.

FORMAL MODEL:
The formal methods model is an approach to software engineering that applies
mathematical methods or techniques to the process of developing complex software
systems. The approach uses a formal specification language to define each characteristic of
the system. The language is very particular and employs a unique syntax whose
components includes objects, relations, and rules.

When used together, these components can validate the correctness of each characteristic.
Think of the process like balancing a series of equations. At each step in the series, if the
right-side of the equation doesn’t equal the left, there's a problem that must be addressed.

CONCEPT OF AGILITY:
• Agility means effective (rapid and adaptive) response to change,
effective communication among all stockholder.
• Drawing the customer onto team and organizing a team so that it
is in control of work performed. -The Agile process, light-weight
methods are People-based rather than plan-based methods.The
agile process forces the development team to focus on software
itself rather than design and documentation. The agile process
believes in iterative method. The aim of agile process is to deliver
the working model of software quickly to the customer For
example: Extreme programming is the best known of agile
process.
• Agility is applied to any software method. However, to accomplish
this, it’s essential that the method be designed during a manner that
enables the project team to adapt tasks and to contour them, conduct
coming up within a good manner that understands the fluidity of an
agile development approach, eliminate about the foremost essential
work products and keeps them lean, Associate in emphasize a
progressive delivery strategy that gets operating package to the client
as apace as possible for the merchandise sort and operational
atmosphere.

Agile development
Agile development is a project management methodology that values individuals
and interactions over processes and tools. The Agile Manifesto, which was created in
2001, outlines the four main values and twelve principles of Agile development. Agile
development is important because it helps to ensure that development teams
complete projects on time and within budget. It also helps to improve
communication between the development team and the product owner.
Additionally, Agile development methodology can help reduce the risks associated
with complex projects. It allows for development teams to make changes quickly and
easily without affecting the overall project timeline

The four Agile values give you an inside look at what the methodology is founded
upon:

• Individuals and interactions over processes and tools

• Working software over comprehensive documentation
• Customer collaboration over contract negotiation
• Responding to change by following a plan

In other words, Agile development focuses on creating working software quickly,

collaborating with customers frequently, and being able to adapt to changes easily.
This methodology is especially beneficial for projects that are complex or have
uncertain requirements.

We can break the Agile process down into three main stages:

1. Preparation
2. Sprint planning
3. Sprint

1. Preparation: In the preparation stage, the product owner creates a backlog of

features they want to include in the final product. This is known as the product backlog.
Then, the development team estimates how long each feature will take to build.

2. Sprint planning: The sprint planning meeting is where the team decides
which features from the product backlog they are going to work on during the sprint.
A sprint is a set period (usually two weeks) during which the development team must
achieve a specific goal. The team also decides how many of each type of task they
can complete during the sprint. For example, the team may decide they can
complete three coding tasks, two testing tasks, and one documentation task during
the sprint. This information is then added to the sprint backlog.

3. Sprint: During the sprint, the team works on completing the tasks in the sprint
backlog. They may also come across new issues to address. If this happens, they will
add these issues to the product backlog and prioritize them accordingly. At the end
of the sprint, the development team should have completed all features in the sprint
backlog. If not, the team will carry them over to the next sprint. The team then holds
a sprint review meeting where they demo completed features to the product owner
and stakeholders. They also discuss what went well during the sprint and how they
could improve their next one. Finally, the team holds a retrospective meeting, where
they reflect on what went well and what didn’t go so well during the sprint. They
then create a plan of action for addressing these issues in future sprints. This
feedback loop helps to ensure that each sprint is more successful than the last.