SOFTWARE ENGINEERING

Module 1
Software development Life Cycle
1. Planning: This is the first phase where you identify what the software needs to
do, who will use it, and how it will be developed. You gather requirements, set
goals, and create a roadmap for the project.
2. Analysis: In this stage, you study the requirements in detail and break them
down into smaller tasks. You also analyze any potential challenges and risks
that may arise during development.
3. Design: Here, you create a blueprint of how the software will look and
function. You design the user interface, database structure, and the overall
architecture of the software.
4. Implementation: This is the actual coding phase, where you write the code
according to the design. Developers work on their assigned tasks, and the
software starts taking shape.
5. Testing: After writing the code, it's time to test the software to find and fix any
bugs or errors. The goal is to ensure the software works correctly and meets
the specified requirements.
6. Deployment: Once the software passes testing, it's ready to be deployed for
actual use. It is made available to users, either internally within an
organization or to the public.
7. Maintenance: Even after deployment, the software requires ongoing support
and updates. This phase involves fixing bugs, making improvements, and
adding new features based on user feedback.
Models
Classical WaterFall model:

1. Easy to Use: Waterfall Model is simple to understand and follow.

2. Less Resources Needed: It requires fewer people and resources to work on the
project.
3. Stable Requirements: The project's requirements remain fixed and do not change
during development.
4. Clear Milestones: There are clear points to track progress at each stage of the
project.
5. Predictable Time and Cost: We can estimate the time and cost of the project before
starting.
6. Easy Customer Understanding: It's easy for customers to understand the progress
due to clear reporting.
Disadvantages:
1. Limited Flexibility
2. Late detection of issues.

Iterative Waterfall model:

1. Flexibility for Changes: It's easier to adjust and add new things as we go along.
2. Early Testing and Feedback: Problems are found early, allowing us to improve the
software quickly.
Disadvantages:
1. Time-Consuming: Developing software in iterations can take longer as each cycle
involves planning, development, and testing.
2. Higher Cost: The iterative approach may lead to increased costs due to the repeated
cycles of development and testing.

Prototyping model:
1. Reduce Maintenance cost.
2. Errors can be detected much earlier as the system is made side by side.
Disadvanatges:
1. Prototyping tools are expensive.
2. Special tools & techniques are required to build a prototype.
In software engineering, a prototype model is an early version of software used to test and
show important features.It helps developers get feedback from users and others before
making the complete software.Prototyping finds mistakes, usability problems, and changes
needed in the software's design early on.Prototypes allow continuous improvements,
making the final software stronger and user-friendly.

Incremental model:
1. Flexible to changes
2. Module by module working
3. Customer Interaction Maximum
4. Large projects

Evolutionary model:
Evolutionary model is the combination of incremental and iterative models of the
software development life cycle. Incremental model builds some features and
delivers to the customers and builds again and delivers to the customers and this
goes on. Prototype model main advantage is the feedback process in every phase.
Combining these two features is there in Evolutionary model.
1. Flexible to changes
2. Risk analysis is better
3. Better suited for larger projects.
Disadvantages: Not suited for smaller projects
Spiral model:
The Spiral Model is a software development process that manages risks and improvements
step by step.It involves iterative cycles called spirals, where planning, analysis, development,
and evaluation happen in stages.This model is great for handling uncertainty and changing
requirements in large and complex projects.By using the Spiral Model, developers can build
high-quality software through continuous refinement and customer feedback.

Radius of spiral = Cost

Angular dimension = Progress

Agile model:
This is the latest software development model.
"Agile" means being quick and flexible. The "Agile process model" is a way of developing
software that focuses on doing things in small steps. Instead of planning everything at the
start, it breaks tasks into smaller parts called iterations. The project's main requirements are
set in the beginning, but the details for each step are not fixed. The number of steps, how
long they will take, and what will be done in each step are decided beforehand. Agile
encourages adaptability, teamwork, and the ability to respond to changes during the
software development process.

Advantages:
1. Frequent Delivering
2. Face to face communication with client
DisAdvantages:
1. Less Documentation
2. Maintenance problem

Module 2
Software Requirements | Requirement Engineering
Requirements engineering (RE) is an important part of the engineering design
process where we figure out, write down, and keep track of what the customer
wants. It helps us understand the customer's needs, check if the ideas are possible,
find a good solution, and clearly explain that solution. We make sure the details are
right and manage these requirements as we turn them into a working system. In
simple words, requirement engineering is the organized use of methods, tools, and
notation to describe how a proposed system should work and what limits it may have
It is a four-step process, which includes -
1. Feasibility Study
2. Requirement Gathering and Analysis
3. Software Requirement Specification
4. Software Requirement Review
5. Software Requirement Management

1. Feasibility Study: At the beginning, we check if the project is possible and worth
doing. We look at technical, economic, legal, and scheduling aspects to see if the
software development idea makes sense.
2. Requirement Gathering and Analysis: In this phase, we talk to different people
involved, like users and clients, to find out what they need from the software. We
carefully study and understand these requirements to make sure they are clear and
complete.
3. Software Requirement Specification: After gathering and understanding the
requirements, we write them down in a detailed document called the Software
Requirement Description. This document explains what the software will do and
what limitations it will have, serving as a reference for everyone involved.
4. Software Requirement Review: We review and check the written requirements to
ensure they accurately represent what people want. Any mistakes or unclear points
are corrected before we move on to the next stages of software development, so we
don't waste time and resources.
5. Software Requirement Management: During the whole software development
process, requirements might change because of new needs or technology.
Requirement Management means keeping track of these changes, talking with
everyone involved, and making sure we handle any modifications in a planned way.
Functional Vs Non-Functional Requirements
Functional Requirements: These are the specific things the software should do or the
functions it should perform. Functional requirements describe the features and
capabilities that the users expect from the software, such as login functionality, data
search, or sending notifications.
Non-Functional Requirements: These are the qualities or characteristics that the
software should have, but they are not directly related to specific functions. Non-
functional requirements focus on how well the software works and its overall
performance. Examples include speed, security, user-friendliness, and reliability.

Aspect Functional Requirements Non-Functional Requirements

Describe what the software should Describe how well the software should
do and its specific functionalities or perform and its overall characteristics or
Focus features. qualities.

Easily verifiable through testing and Verification may be more subjective and
Verifiability validation. require different assessment methods.

Success can be measured by Success may require measuring metrics

checking if specific tasks are like response time, security levels, or
Measurability achieved. user satisfaction.

Software Requirement Specification (SRS)

SRS stands for "Software Requirements Specification." It is a document used in
software engineering to clearly describe what the software will do and how it should
behave. The SRS outlines the functionalities the software will have, user interactions,
and any constraints or limitations. It acts as a roadmap for the developers, guiding
them throughout the project. The SRS helps ensure everyone involved understands
the project's scope and requirements, making communication and collaboration
smoother. It plays a vital role in minimizing misunderstandings and serves as a
reference to assess if the final software meets the intended goals.

Following are the features of good SRS document:

1. Clear and Complete: The SRS should be easy to understand and contain all the
important details, so everyone knows what needs to be done.
 2. Possible and Realistic: The requirements in the SRS should be doable and practical,
considering the available resources and limitations.
3. Measurable and Testable: Each requirement should be easy to measure and check
during testing, ensuring that the software meets the expected standards.

The Structure of SRS document is:

1. Introduction: Gives a quick overview.
2. Overall Description: Describes the software's main functions.
3. Specific Requirements: Details what the software should do.
4. External Interface Requirements: Explains how the software will connect to
other things.
5. Design Constraints: Lists any limits on how the software is built.
6. Software System Attributes: States the qualities the software should have.
7. Other Requirements: Covers any additional needs or rules.

Decision Table and Decision Tree:

A decision table is like a table you use to make decisions. It helps you figure out what
to do based on different situations. It's used in various fields, like making computer
programs, analyzing business situations, or helping with decision-making.In a
decision table, you have two main parts:
1. Conditions (Inputs): These are things that affect your decision. They can be
different options or values you need to check.
2. Actions (Outputs): These are the things you do based on the conditions. They
are the decisions you make or the results you get depending on what the
conditions are.
Here is an example of ATM withdraw:
In software engineering, a decision tree is a graphical representation of the decision-
making process used to solve a problem or make a series of choices in software
development. It is a tree-like model where internal nodes represent decisions based
on certain conditions, and the branches and leaves represent the possible outcomes
or actions resulting from those decisions.

Data Flow Diagrams (DFD):

A Data Flow Diagram (DFD) is like a picture that shows how information moves and
changes in a software system. It helps us understand how data goes from one part of
the system to another. DFDs are important because they let us see how different
parts of the system work together and help us design and analyze the system better.
They also make it easier for everyone involved to talk about the system and
understand how it works.
Symbols of DFD:
Circle: A circle represents a process that takes input data and produces output data.
Data Flow: A curved line shows how data moves into or out of a process or data
store.
Data Store: A set of parallel lines represents a place where data is stored for later use
or by other processes.
Source or Sink: Source or Sink is an external entity that provides input data to the
system or receives output data from the system.