Software Engineering

Introduction to Software Engineering

Software is a program or set of programs containing instructions that provide
desired functionality. And Engineering is the process of designing and
building something that serves a particular purpose and finds a cost-effective
solution to problems.
Software engineering is the process of designing, developing, testing, and
maintaining software. It is a systematic and disciplined approach to software
development that aims to create high-quality, reliable, and maintainable
software. Software engineering includes a variety of techniques, tools, and
methodologies, including requirements analysis, design, testing, and
maintenance.

Some key principles of software engineering include:

1. Modularity: Breaking the software into smaller, reusable

components that can be developed and tested independently.

2. Abstraction: Hiding the implementation details of a component and

exposing only the necessary functionality to other parts of the
software.

3. Encapsulation: Wrapping up the data and functions of an object

into a single unit, and protecting the internal state of an object from
external modifications.

4. Reusability: Creating components that can be used in multiple

projects, which can save time and resources.

5. Maintenance: Regularly updating and improving the software to fix

bugs, add new features, and address security vulnerabilities.

6. Testing: Verifying that the software meets its requirements and is

free of bugs.

7. Design Patterns: Solving recurring problems in software design by

providing templates for solving them.

8. Agile methodologies: Using iterative and incremental

development processes that focus on customer satisfaction, rapid
delivery, and flexibility.
 9. Continuous Integration & Deployment: Continuously integrating
the code changes and deploying them into the production
environment.

Why IT IS USED ?

Software engineering is a rapidly evolving field, and new tools and

technologies are constantly being developed to improve the software
development process. By following the principles of software engineering
and using the appropriate tools and methodologies, software developers can
create high-quality, reliable, and maintainable software that meets the needs
of its users.
Software Engineering is mainly used for large projects based on software
systems rather than single programs or applications. The main goal of
software Engineering is to develop software application for improving the
quality, budget and time efficiency. Software Engineering ensures that the
software that has to built should be consistent, correct, also on budget, on
time and within the required requirements.

Objectives of Software Engineering:

1. Maintainability –
It should be feasible for the software to evolve to meet changing
requirements.

2. Efficiency –
The software should not make wasteful use of computing devices
such as memory, processor cycles, etc.

3. Correctness –
A software product is correct if the different requirements as
specified in the SRS document have been correctly implemented.

4. Reusability –
A software product has good reusability if the different modules of
the product can easily be reused to develop new products.

5. Testability –
Here software facilitates both the establishment of test criteria and
the evaluation of the software with respect to those criteria.

6. Reliability –
It is an attribute of software quality. The extent to which a program
can be expected to perform its desired function, over an arbitrary
time period.
 7. Portability –
In this case, the software can be transferred from one computer
system or environment to another.

8. Adaptability –
In this case, the software allows differing system constraints and
the user needs to be satisfied by making changes to the software.

9. Interoperability – Capability of 2 or more functional units to

process data cooperatively.

Advantages :

1. Improved quality: By following established software engineering

principles and techniques, software can be developed with fewer
bugs and higher reliability.

2. Increased productivity: Using modern tools and methodologies

can streamline the development process, allowing developers to be
more productive and complete projects faster.

3. Better maintainability: Software that is designed and developed

using sound software engineering practices is easier to maintain
and update over time.

Disadvantages:

1. High upfront costs: Implementing a systematic and disciplined

approach to software development can be resource-intensive and
require a significant investment in tools and training.

2. Complexity: With the increase in the number of tools and

methodologies, software engineering can be complex and difficult to
navigate.

3. High maintenance: The software engineering process requires

regular maintenance to ensure that the software is running efficiently,
which can be costly and time-consuming.
Capability maturity model (CMM) :-
CMM was developed by the Software Engineering Institute (SEI) at Carnegie
Mellon University in 1987.
 It is not a software process model. It is a framework that is used to
analyze the approach and techniques followed by any organization
to develop software products.

 It also provides guidelines to further enhance the maturity of the

process used to develop those software products.

 It is based on profound feedback and development practices

adopted by the most successful organizations worldwide.

 This model describes a strategy for software process improvement

that should be followed by moving through 5 different levels.

 Each level of maturity shows a process capability level. All the

levels except level-1 are further described by Key Process Areas
(KPA’s).

Why it is used:
 It encourages the achievement of a higher maturity level in some
cases by displacing the true mission, which is improving the
process and overall software quality.
 It only helps if it is put into place early in the software development
process.
 It has no formal theoretical basis and in fact is based on the
experience of very knowledgeable people.
 It does not have good empirical support and this same empirical
support could also be constructed to support other models.

The 5 levels of CMM are as follows:

Level-1: Initial –
 No KPA’s defined.
 Processes followed are Adhoc and immature and are not well
defined.
 Unstable environment for software development.
 No basis for predicting product quality, time for completion, etc.
Level-2: Repeatable –
 Focuses on establishing basic project management policies.

 Experience with earlier projects is used for managing new similar

natured projects.

Level-3: Defined –
 At this level, documentation of the standard guidelines and
procedures takes place.

 It is a well-defined integrated set of project-specific software

engineering and management processes.

Level-4: Managed –
 At this stage, quantitative quality goals are set for the organization
for software products as well as software processes.

 The measurements made help the organization to predict the

product and process quality within some limits defined
quantitatively.

Level-5: Optimizing –
 This is the highest level of process maturity in CMM and focuses on
continuous process improvement in the organization using
quantitative feedback.

 Use of new tools, techniques, and evaluation of software processes

is done to prevent recurrence of known defects.
SOFTWARE PROCESS MODEL:-

What is a software process model?

In software engineering, a software process model is the mechanism of dividing
software development work into distinct phases to improve design, product
management, and project management. It is also known as a software
development life cycle.

Classical Waterfall Model :-

The classical waterfall model is the basic software development life
cycle model. It is very simple but idealistic. Earlier this model was very
popular but nowadays it is not used. But it is very important because
all the other software development life cycle models are based on the
classical waterfall model.
The classical waterfall model divides the life cycle into a set of phases.
This model considers that one phase can be started after the
completion of the previous phase. That is the output of one phase will
be the input to the next phase. Thus the development process can be
considered as a sequential flow in the waterfall. Here the phases do not
overlap with each other. The different sequential phases of the
classical waterfall model are shown in the below figure:
1. Feasibility Study: The main goal of this phase is to determine whether it
would be financially and technically feasible to develop the software.
The feasibility study involves understanding the problem and then
determining the various possible strategies to solve the problem.

2.Requirements analysis and specification: The aim of the requirement

analysis and specification phase is to understand the exact requirements of
the customer and document them properly. This phase consists of two
different activities.

 Requirement gathering and analysis: Firstly all the requirements

regarding the software are gathered from the customer and then the
gathered requirements are analyzed. The goal of the analysis part is to
remove incompleteness and inconsistencies.

 Requirement specification: These analyzed requirements are

documented in a software requirement specification (SRS) document.
SRS document serves as a contract between the development team
and customers.

3.Design: The goal of this phase is to convert the requirements acquired in

the SRS into a format that can be coded in a programming language. It
includes high-level and detailed design as well as the overall software
architecture. A Software Design Document is used to document all of this
effort (SDD)

4.Coding and Unit testing: In the coding phase software design is

translated into source code using any suitable programming language. Thus
each designed module is coded. The aim of the unit testing phase is to
check whether each module is working properly or not.

5. Integration and System testing: Integration of different modules are

undertaken soon after they have been coded and unit tested. Integration of
various modules is carried out incrementally over a number of steps. During
each integration step, previously planned modules are added to the partially
integrated system and the resultant system is tested. Finally, after all the
modules have been successfully integrated and tested, the full working
system is obtained and system testing is carried out on this.
System testing consists of three different kinds of testing activities as
described below :
 Alpha testing: Alpha testing is the system testing performed by the
development team.

 Beta testing: Beta testing is the system testing performed by a

friendly set of customers.
  Acceptance testing: After the software has been delivered, the
customer performed acceptance testing to determine whether to
accept the delivered software or reject it.

6. Maintenance: Maintenance is the most important phase of a software life

cycle. The effort spent on maintenance is 60% of the total effort spent to
develop a full software. There are basically three types of maintenance :

 Corrective Maintenance: This type of maintenance is carried out to

correct errors that were not discovered during the product
development phase.

 Perfective Maintenance: This type of maintenance is carried out to

enhance the functionalities of the system based on the customer’s
request.

 Adaptive Maintenance: Adaptive maintenance is usually required for

porting the software to work in a new environment such as working on
a new computer platform or with a new operating system.

Advantages:-
Advantages -
 This model is very simple and is easy to understand.
1. Base model
2. Simple and easy  Phases in this model are processed one at a time.
3. Small projects  Each stage in the model is clearly defined.
 This model has very clear and well-understood milestones.

Drawbacks:-

 No feedback path: In the classical waterfall model evolution of

Drawbacks - software from one phase to another phase is like a waterfall. It
1. no feedback assumes that no error is ever committed by developers during any
2. no experiment
3. no parallelism phase. Therefore, it does not incorporate any mechanism for error
4. high risk correction.
5. 60% efforts maintenance
 Difficult to accommodate change requests: This model assumes
that all the customer requirements can be completely and correctly
defined at the beginning of the project, but actually customers’
requirements keep on changing with time. It is difficult to
accommodate any change requests after the requirements
specification phase is complete.

 No overlapping of phases: This model recommends that a new

phase can start only after the completion of the previous phase. But
in real projects, this can’t be maintained. To increase efficiency and
reduce cost, phases may overlap.
Incremental Process Model:-

C- Communication

P - Planning

M – Modeling

C - Construction

D - Deployment
 Explanation:-

 Rather than deliver the system as a single delivery, the development and delivery is
broken down into increments with each increment delivering part of the required
functionality.

 First Increment is often core product

 Includes basic requirement
 Many supplementary features (known & unknown) remain undelivered

 A plan of next increment is prepared

 Modifications of the first increment
 Additional features of the first increment

 It is particularly useful when enough staffing is not available for the whole project

 Increment can be planned to manage technical risks.

 Incremental model focus more on delivery of operation product with each increment
  User requirements are prioritised and the highest priority requirements are included
in early increments.

 Once the development of an increment is started, the requirements are frozen thoug
though requirements for later increments can continue to evolve.

 Customer value can be delivered with each increment so system functionality is availa
earlier.

 Early increments act as a prototype to help elicit requirements for later increments.

 Lower risk of overall project failure.

 The highest priority system services tend to receive the most testing.

Advantages-
1. Prepares the software fast.

2. Clients have a clear idea of the project.

3. Changes are easy to implement.

4. Provides risk handling support, because of its iterations.

Disadvantages-

1. A good team and proper planned execution are required.

2. Because of its continuous iterations the cost increases.

Prototyping model - geeksforgeeks
Rapid application development model
(RAD) :-
The Rapid Application Development Model was first proposed by IBM in
the 1980s. The critical feature of this model is the use of powerful
development tools and techniques. A software project can be
implemented using this model if the project can be broken down into
small modules wherein each module can be assigned independently to
separate teams. These modules can finally be combined to form the
final product.

This model consists of 4 basic phases:

 1. Requirements Planning – It involves the use of various techniques
used in requirements elicitation like brainstorming, task analysis,
form analysis, user scenarios, FAST (Facilitated Application
Development Technique), etc. It also consists of the entire structured
plan describing the critical data, methods to obtain it, and then
processing it to form a final refined model.

2. User Description – This phase consists of taking user feedback and

building the prototype using developer tools. In other words, it
includes re-examination and validation of the data collected in the
first phase. The dataset attributes are also identified and elucidated
in this phase.

3. Construction – In this phase, refinement of the prototype and

delivery takes place. It includes the actual use of powerful automated
tools to transform process and data models into the final working
product. All the required modifications and enhancements are too
done in this phase.

4. Cutover – All the interfaces between the independent modules

developed by separate teams have to be tested properly. The use of
powerfully automated tools and subparts makes testing easier. This
is followed by acceptance testing by the user.

When to use RAD Model?

When the customer has well-known requirements, the user is involved

throughout the life cycle, the project can be time boxed, the functionality
delivered in increments, high performance is not required, low technical risks
are involved and the system can be modularized. In these cases, we can use
the RAD Model.

Advantages:

 The use of reusable components helps to reduce the cycle time of

the project.
 Feedback from the customer is available at the initial stages.
 Reduced costs as fewer developers are required.
 The use of powerful development tools results in better quality
products in comparatively shorter time spans.
 The progress and development of the project can be measured
through the various stages.
 It is easier to accommodate changing requirements due to the short
iteration time spans.
Disadvantages:

 The use of powerful and efficient tools requires highly skilled

professionals.
 The absence of reusable components can lead to the failure of the
project.
 The team leader must work closely with the developers and
customers to close the project in time.
 The systems which cannot be modularized suitably cannot use this
model.
 Customer involvement is required throughout the life cycle.
 It is not meant for small-scale projects as in such cases, the cost of
using automated tools and techniques may exceed the entire budget
of the project.

Applications:

1. This model should be used for a system with known requirements

and requiring a short development time.
2. It is also suitable for projects where requirements can be
modularized and reusable components are also available for
development.
3. The model can also be used when already existing system
components can be used in developing a new system with minimum
changes.

Spiral Model :-
Spiral model is one of the most important Software Development Life
Cycle models, which provides support for Risk Handling. In its
diagrammatic representation, it looks like a spiral with many loops. The
exact number of loops of the spiral is unknown and can vary from
project to project. Each loop of the spiral is called a Phase of the
software development process.

The Spiral Model is a software development life cycle (SDLC) model that
provides a systematic and iterative approach to software development. It is
based on the idea of a spiral, with each iteration of the spiral representing a
complete software development cycle, from requirements gathering and
analysis to design, implementation, testing, and maintenance.
The Spiral Model is a risk-driven model, meaning that the focus is on
managing risk through multiple iterations of the software development
process. It consists of the following phases:
 1. Planning: The first phase of the Spiral Model is the planning phase,
where the scope of the project is determined and a plan is created
for the next iteration of the spiral.

2. Risk Analysis: In the risk analysis phase, the risks associated with
the project are identified and evaluated.

3. Engineering: In the engineering phase, the software is developed

based on the requirements gathered in the previous iteration.

4. Evaluation: In the evaluation phase, the software is evaluated to

determine if it meets the customer’s requirements and if it is of high
quality.

1. The below diagram shows the different phases of the Spiral

Model: –

Each phase of the Spiral Model is divided into four quadrants as shown in
the above figure. The functions of these four quadrants are discussed
below-
 1. Objectives determination and identify alternative
solutions: Requirements are gathered from the customers and the
objectives are identified, elaborated, and analyzed at the start of
every phase. Then alternative solutions possible for the phase are
proposed in this quadrant.

2. Identify and resolve Risks: During the second quadrant, all the
possible solutions are evaluated to select the best possible solution.
Then the risks associated with that solution are identified and the
risks are resolved using the best possible strategy. At the end of
this quadrant, the Prototype is built for the best possible solution.

3. Develop next version of the Product: During the third quadrant,

the identified features are developed and verified through testing. At
the end of the third quadrant, the next version of the software is
available.

4. Review and plan for the next Phase: In the fourth quadrant, the
Customers evaluate the so far developed version of the software. In
the end, planning for the next phase is started.

Advantages of Spiral Model:

Below are some advantages of the Spiral Model.
1. Risk Handling: The projects with many unknown risks that occur
as the development proceeds, in that case, Spiral Model is the best
development model to follow due to the risk analysis and risk
handling at every phase.
2. Good for large projects: It is recommended to use the Spiral
Model in large and complex projects.
3. Flexibility in Requirements: Change requests in the
Requirements at later phase can be incorporated accurately by
using this model.
4. Customer Satisfaction: Customer can see the development of the
product at the early phase of the software development and thus,
they habituated with the system by using it before completion of the
total product.

Disadvantages of Spiral Model :-

1. Complex: The Spiral Model is much more complex than other

SDLC models.

2. Expensive: Spiral Model is not suitable for small projects as it is

expensive.
3. Complexity: The Spiral Model can be complex, as it involves multiple
iterations of the software development process.

4. Time-Consuming: The Spiral Model can be time-consuming, as it

requires multiple evaluations and reviews.

CONCURRENT DEVELOPMENT MODEL :-

Component Based Software
Engineering :-
Component-Based Software Engineering (CBSE) is a process that focuses
on the design and development of computer-based systems with the use of
reusable software components.
It not only identifies candidate components but also qualifies each
component’s interface, adapts components to remove architectural
mismatches, assembles components into a selected architectural style, and
updates components as requirements for the system change.
Component-based development:
Component-based development (CBD) is a CBSE activity that occurs in
parallel with domain engineering. Using analysis and architectural design
methods, the software team refines an architectural style that is appropriate
for the analysis model created for the application to be built.
 (study from agile development pdf)

Agile Development Models :-

The Agile model was primarily designed to help a project adapt to change
requests quickly. So, the main aim of the Agile model is to facilitate quick
project completion. To accomplish this task agility is required. Agility is
achieved by fitting the process to the project and removing activities that may
not be essential for a specific project. Also, anything that is waste of time and
effort is avoided.
Actually Agile model refers to a group of development processes. These
processes share some basic characteristics but do have certain subtle
differences among themselves.
Agile SDLC models:
 Crystal: Crystal Agile methodology places a strong emphasis on
fostering effective communication and collaboration among team
members, as well as taking into account the human elements that
are crucial for a successful development process. This
methodology is particularly beneficial for projects with a high degree
of uncertainty, where requirements tend to change frequently.
  Atern: This methodology is tailored for projects with moderate to
high uncertainty, where requirements are prone to change
frequently. Its clear-cut roles and responsibilities focus on delivering
working software in short time frames, and governance practices
set it apart and make it an effective approach for teams and
projects.
 Feature-driven development: This approach is implemented by
utilizing a series of techniques like creating feature lists, conducting
model evaluations, and implementing a design-by-feature method
to meet its goal. This methodology is particularly effective in
ensuring that the end product is delivered in a timely manner and
that it aligns with the requirements of the customer.

 Scrum: This methodology serves as a framework for tackling

complex projects and ensuring their successful completion. It is led
by a Scrum Master, who oversees the process, and a Product
Owner, who establishes the priorities. The Development Team,
accountable for delivering the software, is another key player.

 Extreme programming (XP): It uses specific practices like pair

programming, continuous integration, and test-driven development
to achieve these goals. Extreme programming is ideal for projects
that have high levels of uncertainty and require frequent changes,
as it allows for quick adaptation to new requirements and feedback.

 Lean development: It is rooted in the principles of Lean

Manufacturing and aims to streamline the process by identifying
and removing unnecessary steps and activities. This is achieved
through practices such as continuous improvement, visual
management, and value stream mapping, which helps in identifying
areas of improvement and implementing changes accordingly.

 Unified process: Unified Process is a methodology that can be

tailored to the specific needs of any given project. It combines
elements of both waterfall and Agile methodologies, allowing for an
iterative and incremental approach to development. This means
that the UP is characterized by a series of iterations, each of which
results in a working product increment, allowing for continuous
improvement and delivery of value to the customer.

The agile model is a combination of iterative and incremental process

models. The steps involve in agile SDLC models are:
 Requirement gathering
 Requirement Analysis
 Design
  Coding
 Unit testing
 Acceptance testing
The time to complete an iteration is known as a Time Box. Time-box refers to
the maximum amount of time needed to deliver an iteration to customers. So,
the end date for an iteration does not change. However, the development
team can decide to reduce the delivered functionality during a Time-box if
necessary to deliver it on time. The central principle of the Agile model is the
delivery of an increment to the customer after each Time-box.
Principles of Agile model:

 To establish close contact with the customer during development

and to gain a clear understanding of various requirements, each
Agile project usually includes a customer representative on the
team.

 The agile model relies on working software deployment rather than

comprehensive documentation.

 Frequent delivery of incremental versions of the software to the

customer representative in intervals of a few weeks.

 Requirement change requests from the customer are encouraged and

efficiently incorporated.

 It emphasizes having efficient team members and enhancing

communications among them is given more importance.

Advantages:
 Working through Pair programming produces well-written compact
programs which have fewer errors as compared to programmers
working alone.
 It reduces the total development time of the whole project.
 Agile development emphasizes face-to-face communication among
team members, leading to better collaboration and understanding of
project goals.
 Customer representatives get the idea of updated software
products after each iteration. So, it is easy for him to change any
requirement if needed.

Disadvantages:
 The lack of formal documents creates confusion and important
decisions taken during different phases can be misinterpreted at
any time by different team members.
  Agile development models often involve working in short sprints,
which can make it difficult to plan and forecast project timelines and
deliverables. This can lead to delays in the project and can make it
difficult to accurately estimate the costs and resources needed for
the project.

 Agile development models require a high degree of expertise from

team members, as they need to be able to adapt to changing
requirements and work in an iterative environment. This can be
challenging for teams that are not experienced in agile development
practices and can lead to delays and difficulties in the project.

Extreme Programming (XP) :-

Extreme programming (XP) is one of the most important software
development frameworks of Agile models. It is used to improve
software quality and responsiveness to customer requirements. The
extreme programming model recommends taking the best practices
that have worked well in the past in program development projects to
extreme levels. Good practices need to be practiced in extreme
programming.

Some of the good practices that have been recognized in the extreme
programming model and suggested to maximize their use are given below:
 Code Review: Code review detects and corrects errors efficiently.
It suggests pair programming as coding and reviewing of written
code carried out by a pair of programmers who switch their works
between them every hour.
 Testing: Testing code helps to remove errors and improves its
reliability. XP suggests test-driven development (TDD) to
continually write and execute test cases. In the TDD approach test
cases are written even before any code is written.
 Incremental development: Incremental development is very good
because customer feedback is gained and based on this
development team comes up with new increments every few days
after each iteration.
 Simplicity: Simplicity makes it easier to develop good quality code
as well as to test and debug it.
 Design: Good quality design is important to develop good quality
software. So, everybody should design daily.
 Integration testing: It helps to identify bugs at the interfaces of
different functionalities. Extreme programming suggests that the
 developers should achieve continuous integration by building and
performing integration testing several times a day.

Basic principles of Extreme programming: XP is based on the

frequent iteration through which the developers implement User
Stories. User stories are simple and informal statements of the
customer about the functionalities needed. A User Story is a
conventional description by the user of a feature of the required
system. It does not mention finer details such as the different
scenarios that can occur.

Some of the basic activities that are followed during software development
by using the XP model are given below:
 Coding: The concept of coding which is used in the XP model is
slightly different from traditional coding. Here, the coding activity
includes drawing diagrams (modeling) that will be transformed into
code, scripting a web-based system, and choosing among several
alternative solutions.

 Testing: XP model gives high importance to testing and considers

it to be the primary factor to develop fault-free software.

 Listening: The developers need to carefully listen to the customers

if they have to develop good quality software. Sometimes
programmers may not have the depth knowledge of the system to
be developed. So, the programmers should understand properly the
functionality of the system and they have to listen to the customers.

 Designing: Without a proper design, a system implementation

becomes too complex and very difficult to understand the solution,
thus making maintenance expensive. A good design results
elimination of complex dependencies within a system. So, effective
use of suitable design is emphasized.

 Feedback: One of the most important aspects of the XP model is to

gain feedback to understand the exact customer needs. Frequent
contact with the customer makes the development effective.

 Simplicity: The main principle of the XP model is to develop a

simple system that will work efficiently in the present time, rather
than trying to build something that would take time and may never
be used.
Applications of Extreme Programming (XP): Some of the projects that are
suitable to develop using the XP model are given below:

 Small projects: XP model is very useful in small projects

consisting of small teams as face-to-face meeting is easier to
achieve.
 Projects involving new technology or Research projects: This
type of project face changing requirements rapidly and technical
problems. So XP model is used to complete this type of project.

Requirements Engineering Process:-

Requirements engineering is the process of identifying, eliciting,
analyzing, specifying, validating, and managing the needs and
expectations of stakeholders for a software system.
OR
Requirement Engineering is the process of defining, documenting and
maintaining the requirements. It is a process of gathering and defining
service provided by the system. it is the disciplined application of
proven principle , methods ,tools and notations to describe a proposed
system’s intended behavior and its associated constraints.
 Requirements Elicitation: This is the process of gathering
information about the needs and expectations of stakeholders for
the software system. This step involves interviews, surveys, focus
groups, and other techniques to gather information from
stakeholders.
 Requirements Specification: This step involves documenting the
requirements identified in the analysis step in a clear, consistent,
and unambiguous manner. This step also involves prioritizing and
grouping the requirements into manageable chunks.
 Requirements Validation: This step involves checking that the
requirements are complete, consistent, and accurate. It also
involves checking that the requirements are testable and that they
meet the needs and expectations of stakeholders.

 Requirements Management: This step involves managing the

requirements throughout the software development life cycle,
including tracking and controlling changes, and ensuring that the
requirements are still valid and relevant.
REQUIREMENT ANALYSIS :-

 Requirements Analysis: This step involves analyzing the

information gathered in the requirements elicitation step to identify
the high-level goals and objectives of the software system. It also
involves identifying any constraints or limitations that may affect the
development of the software system.

What is requirement analysis and documentation?

The requirement analysis document collects, organizes, and tracks the project
requirements from key stakeholders. It guides project planning and ensures you
complete your projects aligned with stakeholder and business goals.

Requirements Analysis in detail:-

Requirement analysis is significant and essential activity after elicitation. We analyze,
refine, and scrutinize the gathered requirements to make consistent and unambiguous
requirements. This activity reviews all requirements and may provide a graphical view
of the entire system. After the completion of the analysis, it is expected that the
understandability of the project may improve significantly. Here, we may also use the
interaction with the customer to clarify points of confusion and to understand which
requirements are more important than others.
The various steps of requirement analysis are shown in fig:

(i) Draw the context diagram: The context diagram is a simple model that defines
the boundaries and interfaces of the proposed systems with the external world. It
identifies the entities outside the proposed system that interact with the system. The
context diagram of student result management system is given below:

(ii) Development of a Prototype (optional): One effective way to find out what the
customer wants is to construct a prototype, something that looks and preferably acts
as part of the system they say they want. We can use their feedback to modify the
prototype until the customer is satisfied continuously. Hence, the prototype helps the client to
visualize the proposed system and increase the understanding of the requirements. When
developers and users are not sure about some of the elements, a prototype may help both the
parties to take a final decision.

(iii) Model the requirements: This process usually consists of various graphical
representations of the functions, data entities, external entities, and the relationships
between them. The graphical view may help to find incorrect, inconsistent, missing,
and superfluous requirements. Such models include the Data Flow diagram, Entity-
Relationship diagram, Data Dictionaries, State-transition diagrams, etc.

(iv) Finalise the requirements: After modeling the requirements, we will have a better
understanding of the system behavior. The inconsistencies and ambiguities have been
identified and corrected. The flow of data amongst various modules has been
analyzed. Elicitation and analyze activities have provided better insight into the system.
Now we finalize the analyzed requirements, and the next step is to document these
requirements in a prescribed format.

Requirements verification and validation:-

Verification: It refers to the set of tasks that ensures that the software
correctly implements a specific function.

Validation: It refers to a different set of tasks that ensures that the software
that has been built is traceable to customer requirements. If requirements
are not validated, errors in the requirement definitions would propagate to
the successive stages resulting in a lot of modification and rework. The main
steps for this process include:
 The requirements should be consistent with all the other
requirements i.e no two requirements should conflict with each
other.
 The requirements should be complete in every sense.
 The requirements should be practically achievable.

 Verification is the process of checking that the requirements are

complete, consistent, and accurate. It involves reviewing the
requirements to ensure that they are clear, testable, and free of errors
and inconsistencies. This can include reviewing the requirements
document, models, and diagrams, and holding meetings and
walkthroughs with stakeholders.
  Validation is the process of checking that the requirements meet the
needs and expectations of the stakeholders. It involves testing the
requirements to ensure that they are valid and that the software
system being developed will meet the needs of the stakeholders. This
can include testing the software system through simulation, testing
with prototypes, and testing with the final version of the software.

Analysis Modelling in Software

Engineering :-
Analysis Model is a technical representation of the system. It acts as a link
between system description and design model. In Analysis Modelling,
information, behavior, and functions of the system are defined and translated
into the architecture, component, and interface level design in the design
modeling.
Objectives of Analysis Modelling:
 It must establish a way of creating software design.
 It must describe the requirements of the customer.
 It must define a set of requirements that can be validated, once the
software is built.

Elements of Analysis Model:

Data-Dictionary:
It is a repository that consists of a description of all data objects used or
produced by the software. It stores the collection of data present in the
software. It is a very crucial element of the analysis model. It acts as a
centralized repository and also helps in modeling data objects defined during
software requirements.

Entity-Relationship-Diagram(ERD):
It depicts the relationship between data objects and is used in conducting data
modeling activities. The attributes of each object in the Entity-Relationship
Diagram can be described using Data object description. It provides the basis
for activity related to data design.

Data-Flow-Diagram(DFD):
It depicts the functions that transform data flow and it also shows how data is
transformed when moving from input to output. It provides the additional
information which is used during the analysis of the information domain and
serves as a basis for the modeling of function. It also enables the engineer to
develop models of functional and information domains at the same time.

State-Transition-Diagram:
It shows various modes of behavior (states) of the system and also shows the
transitions from one state to another state in the system. It also provides the
details of how the system behaves due to the consequences of external
events. It represents the behavior of a system by presenting its states and the
events that cause the system to change state. It also describes what actions
are taken due to the occurrence of a particular event.

Process-Specification:
It stores the description of each function present in the data flow diagram. It
describes the input to a function, the algorithm that is applied for the
transformation of input, and the output that is produced. It also shows
regulations and barriers imposed on the performance characteristics that are
applicable to the process and layout constraints that could influence the way
in which the process will be implemented.

Control--Specification:
It stores additional information about the control aspects of the software. It is
used to indicate how the software behaves when an event occurs and which
processes are invoked due to the occurrence of the event. It also provides the
details of the processes which are executed to manage events.
Data-Object-Description:
It stores and provides complete knowledge about a data object present and
used in the software. It also gives us the details of attributes of the data object
present in the Entity Relationship Diagram. Hence, it incorporates all the data
objects and their attributes.

DATA MODELING :-
What is data modeling in software engineering?
Data modeling is the process of creating a simplified diagram of a software
system and the data elements it contains, using text and symbols to represent
the data and how it flows.

Data modeling is a method that helps you avoid the cons that come
with poorly designed data. It’s like a map that helps organize
information for better use.
Why Do We Need a Data Model?
You need a data model to ensure that the developer has a structure of data
objects and their flow. Data models help in designing a database at a physical
and logical level. A data model also defines primary keys, foreign keys,
relational tables, and stored procedures. Once the developers have an idea of
how the data flows, they can create a physical database.
When you sort data in the correct order, you can find out which data is
unclear. You can also look for missing information and take action. In the long
run, this helps in upgrading the base of your project or company. Not only that,
maintenance costs go down with a proper data model in action.
Types of Data Model :-
From the definition above, we know that the data model defines the structure
of a database. It does so at a physical, conceptual, and logical level. Let’s check
out the three main types of data models.
Conceptual :-
The conceptual data model defines what the system is made of. Data
architects and stakeholders create this model. The aim is to define, set the
scope, and organize different rules and business concepts. This model aims to
define entities, how those entities relate to each other, and their attributes.
For instance, let’s consider two entities, customer and product. The customer’s
name and ID are the attributes of the customer. The price and name are the
entities of the product. We can say that sales is the connection between the
product and the customer.
Physical :-
A physical data model has more details than a conceptual one. Also, the
physical model defines all the things that a developer needs to build a
database. Apart from all those in the conceptual model, a physical data model
has properties like column names, table structures, and foreign keys.
There are two ways of creating a physical data model. You can create it by
modifying the existing logical model. Or, you can use the native DBMS
language. Database admins use the physical data model to plan the database’s
capacity.
Logical :-
The logical data model is responsible for defining the structure of different
data elements. The design and development of this model don’t depend on
DBMS. In this model, you need not define the primary and secondary keys. You
need only verify the details and adjust the connector between the entity and
attributes. This model is the same as the conceptual model, only a bit more
detailed.
Data Modeling Steps :-
Because there’s ample data to cater to, data modeling happens step-wise. Let’s
take a look at the steps of data modeling.
Identify Entities :-
We first consider raw data into different sets, each modeled separately. Each
set has some business objects or entities. The first step is to identify these
entities.
Identify a Key Property :-
Every entity has a key property. This way, you can differentiate between
entities in a data model. For instance, in an employee data model, employee ID
is a unique property.
Create a Rough Draft :_
Entities in a data set form a connection with each other in some way or
another. Make a rough draft to display how the entities connect with each
other.
Identify Different Data Attributes :-
After creating a rough draft, identify different data attributes or properties.
Incorporate these attributes into the data model.
Map Out the Attributes :-
Map the attributes to entities after identifying various attributes. This way, the
Entity-Relationship model will show what the data means from a business
point of view. For instance, let’s consider the employee data model we
discussed

ADVANTAGES :-

1. Lower Costs
Data models help in lowering the cost of development. Generally, companies
spend a lot of funds on coding and testing. Data modeling reduces the
company’s coding budget. Not only that, the best part is that data models
don’t use a lot from the budget.
2. Better Management of Data as a Resource
You can normalize your data with data modeling. You can also define the data
in terms of what it is. Not only that, you can even define data in terms of the
properties it can have.
3. Designing Repositories and Databases
Having a smooth-functioning database is a must for every firm. For that, data
modeling is an important process. It also helps in driving better decisions about
archives and data warehouses.
4. Accurate Representation of Objects
Data modeling provides an accurate description of data objects by creating a
flow or diagram. This diagram shows how the entities and their properties
connect with each other or with other elements in the database.
5. Better Performance
Most people think that a database runs slow because of some problem in the
database design. But in reality, without a data model, the database
development is poor. Also, data modeling ensures better performance by
easing the database tuning. When the concepts in a data model are clear, the
developer can design a database that runs faster.

DISADVANTAGE :-
1. You can’t perform data modeling without knowing the features of the
physical data stored.
2. Even if you make only a minor change in the structure later, you’ll need to
modify the entire structure.