GHS CHITTA BATTA

COMPUTER SCIENCE_2
nd
Year (Notes)

System:
A system is a collection of interrelated components or elements that work together to
achieve a common goal or purpose. It can be physical, like a computer system, or
abstract, like an organizational system. Systems can be simple or highly complex, with
inputs, processes, outputs, feedback loops, and boundaries that define their interactions
with the external environment.

SDLC (Software Development Life Cycle) and its Importance:

Software Development Life Cycle (SDLC) is a structured process for planning, creating,
testing, deploying, and maintaining software systems. Its importance lies in ensuring
efficient and high-quality software development by providing a clear framework for
project management and development activities. Here are seven key points about SDLC's
importance:

Structured Approach: SDLC offers a systematic and organized approach to software

development, reducing the likelihood of errors and unpredictability in project outcomes.

Quality Assurance: It focuses on ensuring the quality of the software by defining

standards and best practices for each phase of development.

Cost Control: By setting clear objectives and milestones, SDLC helps control
development costs and prevent budget overruns.

Risk Management: It enables the identification and mitigation of risks early in the
development process, reducing the likelihood of costly issues later.

Customer Satisfaction: SDLC ensures that the end product aligns with customer
expectations by involving them at various stages and seeking feedback.

Documentation: Comprehensive documentation throughout the SDLC process is vital

for future maintenance and for understanding the software's functionality.

Predictable Timelines: It provides a timeline and project plan, helping teams manage
their time and resources effectively.
GHSs(Chap-2 SDLC) Page 1
Objectives of SDLC:
The primary objectives of SDLC are to:

Deliver High-Quality Software: Ensure that the software meets specified quality
standards and requirements.

Manage Costs: Control development costs and resources efficiently.

Minimize Risks: Identify and mitigate potential issues and uncertainties throughout the
project.

Meet User Requirements: Develop software that aligns with user expectations and
needs.

Provide Clear Documentation: Create comprehensive documentation for future

reference and maintenance.

Maintain Consistency: Ensure that the development process follows consistent and
repeatable steps.

Stakeholders in SDLC :
Stakeholders in SDLC are like important players in a team. They include anyone affected
by the software project, such as users, managers, and developers. Each stakeholder has a
role; users express their needs, managers provide resources, and developers create the
software. Their input and satisfaction are crucial. Think of them as the audience in a
theater – their feedback shapes the play. In software development, stakeholders guide the
project, ensuring the final product meets everyone's expectations and requirements,
making their involvement vital for a successful outcome.
Stakeholders in SDLC include:

Management: Senior management oversees the project, provides funding, and ensures
alignment with organizational goals. They make strategic decisions and monitor progress.

Project Manager: The project manager is responsible for planning, executing, and
closing the project. They manage resources, schedules, and communication among team
members and stakeholders.

GHSs(Chap-2 SDLC) Page 2

System Analyst: System analysts analyze business needs and translate them into
system requirements. They act as a bridge between business stakeholders and the
development team.

Programmer: Programmers write code to implement the software based on the design
specifications. They are responsible for the technical implementation of the system.

Software Tester: Testers are responsible for ensuring the quality of the software by
designing and executing test cases, identifying and reporting defects, and verifying that
the software meets the specified requirements.

Customer: The customer, or end-user, is the ultimate beneficiary of the software. Their
role includes defining requirements, providing feedback, and accepting the final product.

SDLC Phases:

1_Planning
2_Feasibility

3_Analysis
4_Requirement
Engineering

6_Coding 5_Design

7_Testing

8_Deployment
9_Maintenance

Planning :

The Planning phase is the foundational stage of the Software Development Life Cycle
(SDLC). During this phase, the project's scope, objectives, and approach are defined. It

GHSs(Chap-2 SDLC) Page 3

sets the stage for the entire project by establishing a clear plan, identifying resources, and
understanding project constraints.

The following are the key activities within the Planning phase:

Project Initiation: This activity involves the initial concept of the project, where
stakeholders identify the need for a software solution and propose its development. It
may include the creation of a project charter or initial business case.

Project Scope Definition: In this activity, the project team outlines the boundaries and
objectives of the project. It defines what is included and excluded in the project, setting
realistic expectations.

Stakeholder Identification: Identifying and involving relevant stakeholders is crucial

for understanding their expectations and requirements.

Project Constraints and Assumptions: Constraints such as budget, time, and resource
availability are identified, along with any assumptions that will guide project planning.

Risk Assessment: A preliminary risk assessment is conducted to identify potential issues

that may arise during the project.

Project Plan Development: The project plan outlines the project's approach, timelines,
deliverables, and resource allocation. It provides a roadmap for the project's execution.

Cost Estimation: An estimate of the project's budget is prepared, considering the cost of
resources, tools, and potential risks.
Feasibility Analysis:

Feasibility studies are conducted to assess the project's viability, which includes
technical, economic, operational, and scheduling feasibility.

Feasibility and Its Types: Feasibility analysis is a critical aspect of the Planning
phase. It evaluates whether the proposed software project is worth pursuing. There are
several types of feasibility that need to be assessed:

Technical Feasibility: This assesses whether the project can be successfully developed
from a technical perspective. It considers factors such as technology stack, infrastructure,
and the availability of necessary skills.

GHSs(Chap-2 SDLC) Page 4

Economic Feasibility: Economic feasibility evaluates whether the project is financially
viable. It considers costs, benefits, and potential returns on investment (ROI). This
analysis helps in determining whether the project is cost-effective and can provide value.

Operational Feasibility: This feasibility focuses on whether the proposed software

system will be operationally effective. It assesses whether the software will integrate well
with existing systems, processes, and workflows.

Scheduling Feasibility: Scheduling feasibility examines whether the project can be

completed within a reasonable time frame. It considers time constraints, dependencies,
and the availability of resources.

Analysis in SDLC:

Imagine you want to build a treehouse. Before you start building, you need to plan.
Analysis in software development is like planning for your treehouse. It's figuring out
what you want, what you need, and how to do it before you actually start building the
software.
Activities in Analysis:

Understanding Needs: Just like understanding you want a treehouse, in analysis, we talk
to people who will use the software. We ask them what they need the software to do. This
helps us understand their requirements.

Gathering Information: We collect all the important details. For a treehouse, it could be
the size, the number of rooms, or the materials needed. In software, it could be data,
processes, or specific functions the software must have.

Breaking Down Requirements: We break down the gathered information into smaller,
manageable parts. Think of it as breaking down your treehouse idea into specific rooms,
windows, and doors.

Creating Specifications: Specifications are like detailed plans for your treehouse. In
software analysis, these are detailed documents that explain exactly what the software
needs to do. It's like having a blueprint for your treehouse construction.

Considering Constraints: Just as you consider the space, budget, and safety for your
treehouse, in software analysis, we think about limitations like time, budget, and

GHSs(Chap-2 SDLC) Page 5

technology constraints. We ensure the software idea is realistic and achievable within
these limitations.

Identifying Risks: Imagine if your tree-house is near a tree that often loses branches.
That's a risk. In software, we identify possible problems or challenges that might happen
during development and figure out how to deal with them.

User Involvement: Just like you might ask your friends for ideas about your tree-house,
software analysis often involves discussions with future users. We want to make sure the
software will be easy and useful for them.

Requirements Engineering :

Requirements engineering is like making a shopping list before you go to the store. When
you need to buy things, you write down what you need and how those things should be.
In the world of software, it's about making a clear list of what the software must do and
how it should do it before starting to build it.

1. Requirement Gathering:
Imagine you're making a list of items you want to buy at the store. In software, this is like
talking to people who will use the software and asking them what they want the software
to do. Some things on the list are what the software needs to do, and some are how it
should do those things.

1. Functional Requirements: These are like the things you need to buy, such as
milk, bread, and eggs. Functional requirements are a list of what the software
needs to do, like "allow users to log in" or "calculate monthly expenses."
2. Non-Functional Requirements: These are like the details of what you need to
buy, such as low-fat milk, whole wheat bread, and organic eggs. Non-functional
requirements are about how well the software should do things, like "load web
pages quickly" or "be secure."
2. Requirements Validation :

Imagine you've made your shopping list, and now you're checking it to make sure you
didn't forget anything and that it all makes sense. In software, this is where we review the
list of what the software needs to do to ensure it's complete and makes sense. We make
sure it's clear and realistic.

GHSs(Chap-2 SDLC) Page 6

 3. Requirements Management:

Think of your shopping list as something that may change. Sometimes you need to add
new items or remove things you no longer need. In software, requirements management
is like keeping track of the list of what the software needs to do. We make sure any
changes are documented, and we understand how they might affect the software project.
It's like making sure your shopping list is always up to date and in good order.

Design:
Design in software development is like making a detailed plan for building something.
Imagine you want to build a tree-house; the design would include how big it is, where the
windows go, and how to make it safe. In software, it's about creating a plan that explains
how the software will work and how it will look.
Types of Design:

There are three main types of design in software development:

Algorithm Design:
An algorithm is like a recipe. It's a step-by-step set of instructions for the computer to
follow to solve a problem.

For example, let's say you want to find the highest number in a list of numbers. The
algorithm might be: "Go through the list one by one, remember the biggest number
you've seen so far, and at the end, that's the highest number."

int findHighest(int numbers[], int size) {

int highest = numbers[0];

for (int i = 1; i < size; i++) {

if (numbers[i] > highest) {

highest = numbers[i];

GHSs(Chap-2 SDLC) Page 7

 return highest;

Flowchart Design:
A flowchart is like a visual map. It shows the steps of the algorithm using shapes and
arrows.For the same example, a flowchart might have boxes for "Start," "Loop through
list," "Check if number is higher," and "End."
Decisio
Start/End Process
Arrow I/O n

Pseudo Code Design:

Pseudo code is like a mix of plain language and code. It's not in any specific
programming language, making it easy for people to understand.

For the same example, the pseudo code might look like:

highest = numbers[0]

for each number in numbers

if number > highest

highest = number

end for

return highest

Each of these design types helps you plan how your software will work. Whether you use
algorithms, flowcharts, or pseudo code, the goal is to have a clear plan before you start
coding, just like knowing how your tree-house will look before you start building it.

Coding:
Coding in software development is like following a recipe to cook a meal. It's where you
take the plan (the design) and write specific instructions for the computer to follow.

GHSs(Chap-2 SDLC) Page 8

These instructions are written using a programming language, such as C++, which the
computer understands. It's how you bring the software to life.

Example of Coding in C++:

Let's take a simple example where we want to write a C++ program to add two numbers
and display the result. Here's the code:

#include <iostream> // Include a library for input and output

int main() { // The main function is where the program starts

// Declare variables to store the numbers

int num1, num2;

// Prompt the user for input

std::cout << "Enter the first number: ";

std::cin >> num1;

std::cout << "Enter the second number: ";

std::cin >> num2;

// Calculate the sum

int sum = num1 + num2;

// Display the result

std::cout << "The sum is: " << sum << std::endl;

return 0; // The program ends here

Here's what's happening in this code:

1. We include the <iostream> library, which allows us to use functions for input and
output.
2. The main function is the starting point of the program.

GHSs(Chap-2 SDLC) Page 9

 3. We declare two integer variables, num1 and num2, to store the two numbers we
want to add.
4. We use std::cout to display a prompt for the user to enter the first number, and
std::cin to read the user's input into num1. The same process is repeated for the
second number.
5. We calculate the sum of num1 and num2 and store it in the sum variable.
6. Finally, we use std::cout to display the result, which is the sum of the two numbers.
7. The return 0; line indicates that the program has completed successfully.

Testing:
Testing/verification in software development is like checking a newly-built car to make
sure it works correctly and safely before it's ready for the road.

Imagine you are the driver of a car, and you want to be sure that all the parts work
as they should. You'd test the brakes, check the lights, and make sure the engine
runs smoothly. In software, testing is similar. It's the process of checking a
computer program to make sure it operates properly and doesn't have any issues.

Here's how testing/verification works:

Test Plans: Just like you'd plan what to test in a car, in software development, you create
a plan that outlines what parts of the program you need to test.

Executing Tests: You perform specific actions on the software to see if it behaves as
expected. For example, you might click buttons in a software application to check if they
perform the intended tasks.

Checking for Problems: You look for any problems or "bugs" in the software. Just as
you'd listen for strange sounds in a car's engine, in software, you check for errors, like the
program crashing or not producing the correct results.

Fixing and Retesting: If you find issues, you report them, and the software developers
fix them. Then, you retest to make sure the problems are resolved.

Repeat and Improve: Testing is often an ongoing process. You keep testing, identifying
issues, and making improvements until the software works as expected and is ready for
use, much like how a car is tested and improved until it's safe to drive.

GHSs(Chap-2 SDLC) Page 10

Deployment/Implementation:
Deployment/Implementation in software development is like launching a new product.
Once you've built your software, it's time to make it available for people to use. This
phase involves all the activities that lead to the software going live.

Deployment/Implementation Activities:

Installation: The software is installed on the target environment, whether it's a user's
computer, a server, or a cloud platform.

Configuration: Any necessary settings are configured to ensure the software works
correctly. This includes setting up databases, networks, and user access permissions.

Data Migration: If the software replaces an older system, existing data may need to be
transferred to the new system. This is called data migration.

Testing: Before the software is fully launched, a final round of testing is often performed
in the deployment environment to ensure that it operates as expected in its new home.

User Training: If the software is complex or has new features, users may require
training to use it effectively.

Documentation: Detailed documentation is often created to help users understand how

to use the software. This may include user manuals or online help resources.

Rollout: The software is made available to users or the public, depending on the intended
audience.

Monitoring: After deployment, the software is continuously monitored to identify and

address any unexpected issues or performance problems.

Maintenance/Support:
Maintenance and support are ongoing activities that ensure the software remains in good
working order and continues to meet user needs. Just like a car requires regular servicing
to stay roadworthy, software needs care and attention to remain useful.

Types of Maintenance/Support:
GHSs(Chap-2 SDLC) Page 11
Corrective Maintenance: This involves fixing any errors or bugs that users encounter.
When users report problems, developers identify, resolve, and test the fixes.

Adaptive Maintenance: Software needs to adapt to changes in the environment. This

includes updates to work with new operating systems or to meet evolving security
requirements.

Perfective Maintenance: Over time, users might request new features or improvements
to existing ones. Perfective maintenance involves enhancing the software to meet these
needs.

Preventive Maintenance: This aims to identify and fix potential issues before they cause
problems. It might involve routine performance optimization or making sure the software
remains compatible with the latest technologies.

Support Activities:
Help Desk: A support team helps users with their questions and problems. They may
provide assistance over the phone, via email, or through online chat.

Patch Management: Regularly, patches and updates are released to address security
vulnerabilities and improve the software. These updates need to be managed and applied
to maintain the software's security.

Backup and Recovery: Systems for backing up data and recovering from disasters are
established to ensure that data remains safe and can be restored if necessary.

Role of Management in SDLC

Management in SDLC is like the captain of a ship. They set the course and provide
direction for the entire project. They make important decisions, allocate resources, and
ensure the project aligns with the organization's goals.

1. Responsibilities: Management oversees the project, provides funding, and makes

high-level decisions. They ensure that the project is on track, within budget, and
meets its objectives.

Project Manager in SDLC :

GHSs(Chap-2 SDLC) Page 12

A project manager in SDLC is like a conductor of an orchestra. They coordinate all the
activities, keep everyone in sync, and make sure the project progresses smoothly. They
manage schedules, budgets, and communication among team members and stakeholders.

2. Responsibilities: The project manager creates a detailed plan, assigns tasks, and
tracks progress. They solve problems, manage risks, and ensure the project stays
on schedule and within budget.

System Analyst in SDLC:

A system analyst in SDLC is like a detective. They investigate and understand the needs
of the business and translate them into technical requirements. They bridge the gap
between the business and the development team, making sure everyone understands each
other.

1. Responsibilities: System analysts gather and document business requirements,

making sure that the software will address the needs of the users. They also help
resolve any conflicts or misunderstandings between stakeholders.

Programmer in SDLC :
A programmer in SDLC is like a chef in a kitchen. They take the recipe (the design) and
prepare the dish (write the code). They turn the plan into a functioning software by
writing lines of code in a programming language.

1. Responsibilities: Programmers write, test, and maintain the code that makes the
software work. They ensure that the software follows the design and meets the
specified requirements.

Software Tester in SDLC :

A software tester in SDLC is like a quality control inspector in a factory. They carefully
examine the product (the software) to make sure it's of high quality and free of defects.
Testers design and execute tests to check if the software works correctly.

1. Responsibilities: Testers create test cases, execute them, and report any issues or
bugs they find. They ensure that the software meets the specified requirements and
is free from errors.

GHSs(Chap-2 SDLC) Page 13

Customer in SDLC :
The customer in SDLC is like the person who orders a custom cake. They are the ones
who need the software and know what they want. Their role is to provide requirements,
feedback, and ultimately accept the final product.

1. Responsibilities: Customers define their needs, expectations, and objectives for

the software. They provide feedback during development and, when satisfied,
accept the final product as meeting their requirements.

END OF CHAP-2 (SDLC)

GHSs(Chap-2 SDLC) Page 14