SOFTWARE ENGINEERING UNIT 1

The Evolving Role of Software

Earlier, software was mainly used for simple tasks like calculations, data storage, and basic
automation. It was mostly limited to offices, scientific work, and large organizations. At that time,
software was considered just a supporting tool for hardware, and its role was not very critical in
daily life.

Over time, the role of software has changed a lot. Today, software is not just a support system but
the core part of almost every activity. It is used in communication, education, healthcare, banking,
transportation, business, and entertainment. Mobile apps, websites, cloud systems, and social
media platforms have made software an essential part of human life. Without software, modern
systems cannot function properly.

In the present era, software also plays a major role in decision-making and automation.
Technologies like artificial intelligence, data analytics, and machine learning depend completely
on software. Software now helps in improving efficiency, reducing human effort, and providing
better services. Because of this, software has become more powerful, complex, and important
than ever before.

# Changing Nature of Software

Definition

The changing nature of software means that software is not fixed anymore. It keeps evolving with
time, technology, and user needs.

# Short Explanation (paragraph)

Earlier, software was simple and mostly used for specific tasks like calculations or record keeping.
Once developed, it was rarely changed. But now software has become more flexible and dynamic.
It is continuously updated, improved, and modified according to user feedback and market
demand. Software today is not just a product, it behaves more like a service that grows over time.

Another important change is that software is now used everywhere — in mobiles, websites,
machines, hospitals, banks, and even daily life activities. Because of this, software must be fast,
secure, and user-friendly. Developers now focus more on regular updates, better user experience,
and long-term maintenance instead of one-time development.

Some points that show changing nature (natural writing)

 • Software has shifted from standalone programs to online and cloud-based systems

• Regular updates and patches have become normal

• Software now needs to handle many users at the same time

• User requirements change fast, so software must be easy to modify

• Security and data protection have become very important

Diagram: Changing Nature of Software

(Diagram explanation: Earlier software was single-use and fixed, but now it is online, service-
based, regularly updated, and user-driven.)

Example (simple)

Earlier, we used offline music players installed once on a computer. Now apps like Spotify work
online, update automatically, and add new features regularly. This clearly shows how software
nature has changed.

# Layered Technology (Software Engineering)

Definition

Layered technology in software engineering means the software is built in different layers. Each
layer has its own work and responsibility. These layers work together to make software
development easier and more organized.

Explanation

In layered technology, software is divided into multiple levels so that complexity can be managed
properly. Each layer depends on the layer below it and provides service to the layer above it. This
approach helps developers to understand, design, and maintain software in a better way. If any
problem occurs in one layer, it can be fixed without disturbing the whole system.

Main Layers of Software Engineering

1. Quality Focus
This layer is responsible for improving the quality of software. It ensures that standards,
reviews, and testing are done properly so that software works correctly.

2. Process Layer
The process layer defines the steps required to develop software, such as requirement
analysis, design, coding, testing, and maintenance.

3. Methods Layer
This layer includes technical methods like requirement specification, system modeling,
program design, and testing techniques.

4. Tools Layer
Tools provide automated or semi-automated support to the process and methods.
Examples include IDEs, testing tools, and version control systems.

Diagram: Layered Technology in Software Engineering

Advantages of Layered Technology

• Makes software development systematic and organized

• Easy to maintain and modify software

 • Improves quality and reliability

• Reduces complexity of large systems

# Changing Nature of Software

Definition

The changing nature of software means that software is not fixed anymore. It keeps evolving with
time, technology, and user needs.

# Short Explanation (paragraph)

Earlier, software was simple and mostly used for specific tasks like calculations or record keeping.
Once developed, it was rarely changed. But now software has become more flexible and dynamic.
It is continuously updated, improved, and modified according to user feedback and market
demand. Software today is not just a product, it behaves more like a service that grows over time.

Another important change is that software is now used everywhere — in mobiles, websites,
machines, hospitals, banks, and even daily life activities. Because of this, software must be fast,
secure, and user-friendly. Developers now focus more on regular updates, better user experience,
and long-term maintenance instead of one-time development.

Some points that show changing nature (natural writing)

• Software has shifted from standalone programs to online and cloud-based systems

• Regular updates and patches have become normal

• Software now needs to handle many users at the same time

• User requirements change fast, so software must be easy to modify

• Security and data protection have become very important

Diagram: Changing Nature of Software

(Diagram explanation: Earlier software was single-use and fixed, but now it is online, service-
based, regularly updated, and user-driven.)

Example (simple)

Earlier, we used offline music players installed once on a computer. Now apps like Spotify work
online, update automatically, and add new features regularly. This clearly shows how software
nature has changed.

A Process Framework

Definition

A process framework in software engineering is a basic structure that defines the main activities
required to develop software. It provides a common outline that guides developers from the start
of the project till the final delivery of the software.

Short Explanation

A process framework acts like a roadmap for software development. It does not tell exact steps
in detail, but it gives a general flow of activities that should be followed in every software project.
This helps developers work in a systematic way instead of doing things randomly.

The framework is flexible in nature. Different projects can add or modify activities according to
their needs, but the core structure remains the same. Because of this, process frameworks are
used in almost all software development models.

Main Activities of a Process Framework

 1. Communication
In this activity, developers talk with customers to understand their requirements clearly.
If communication is weak, the final software may not meet user needs.

2. Planning
Planning includes deciding project schedule, resources, cost, and risks. It helps in
managing time and work properly.

3. Modeling
Modeling means creating designs of the software such as system models, diagrams, and
layouts. It gives a clear picture of how software will work.

4. Construction
This phase includes coding and testing. Actual software is built in this step and errors are
removed.

5. Deployment
In deployment, software is delivered to users. Feedback is collected and future
improvements are planned.

Diagram: Process Framework

Importance of Process Framework

• Gives proper direction to software development

 • Helps in better planning and control

• Reduces chances of mistakes and confusion

• Improves quality of software

• Makes development more organized

Example

In a college management system project, developers first communicate with staff, plan modules,
design screens, write code, test it, and finally deploy the system. All these steps follow a basic
process framework.

Short Conclusion (with small mistakes, natural)

In short, process framework is very useful in software engineering. It helps developer to work
step by step and not get confuse. Without process framework software making become very
difficult.

Process Models

Definition

A process model in software engineering is a structured way to develop software step by step. It
shows how software is planned, designed, developed, tested, and maintained. Process models
help developers understand what work has to be done at each stage of software development.

Short Explanation (Paragraph)

Process models act like a roadmap for building software. Instead of doing everything randomly,
developers follow a fixed sequence of steps. This makes the development process more organized
and easier to manage. Different projects need different process models depending on size,
complexity, and requirements. By using process models, chances of mistakes are reduced and
quality of software improves.

Types of Process Models (Brief Explanation)

Waterfall Model
This is the simplest process model where each phase is completed one by one. Once a phase is
finished, it cannot be changed easily.

Incremental Model
Software is developed in small parts or increments. Each part adds new features to the software.

Iterative Model
Software is developed again and again in cycles. Feedback is taken after each cycle and
improvements are made.

Spiral Model
This model focuses on risk analysis. Development goes in a spiral form with planning, risk
checking, development, and testing.

Why Process Models are Important

• They give clear structure to software development

• Help in planning and scheduling work

• Reduce confusion and errors

• Improve team coordination

• Make software development more systematic

Example (Simple)

If a college wants to develop an attendance management system, a process model helps decide
what to do first (requirements), then design, then coding, testing, and finally deployment.
Without a process model, work can become messy and unplanned.

Short Conclusion (intentionally simple, small mistake style)

In short, process models are very useful in software development. They help developers work in
proper way and reduce problems. Without process model, software making become very difficult
and confusing.

The Waterfall Model

Definition
The Waterfall Model is a traditional software process model where development is done in a step-
by-step linear manner. In this model, each phase must be completed fully before moving to the
next phase.

Short Explanation

The Waterfall model follows a fixed sequence of stages, just like water flowing from top to bottom.
Once a phase is finished, developers do not go back to the previous phase. This model is easy to
understand and simple to manage, especially when project requirements are clear from the
beginning.

Because of its strict structure, planning is done at the start and changes are not easily accepted
later. That is why it is mostly used in small or well-defined projects.

Phases of Waterfall Model

1. Requirement Analysis
In this phase, all software requirements are collected from the customer and clearly
documented.

2. System Design
The overall system architecture and design are prepared based on requirements.

3. Implementation (Coding)
Actual coding of the software is done according to the design.

4. Testing
The software is tested to find errors and bugs before delivery.

5. Deployment
The final product is delivered and installed for the user.

6. Maintenance
Errors found after delivery are fixed and small updates are done.

Diagram – Waterfall Model

(Exam me aisa hi simple diagram banana hota hai)

Advantages of Waterfall Model

• Simple and easy to understand

• Easy to manage because phases are fixed

• Works well when requirements are clear

• Proper documentation is maintained

Disadvantages of Waterfall Model

• Changes are difficult after one phase is completed

• Not suitable for large or complex projects

• Late testing may increase risk

• Customer feedback comes very late

Example

If a small school wants a basic attendance system with fixed requirements, the Waterfall model
can be used because the steps are clear and changes are not expected later.
Short Conclusion (with small student-type mistake)

The waterfall model is simple and easy process model. It is good when requirement are clear but
not good when changes come again and again.

Incremental Process Model

Definition

Incremental process model is a software development model in which the software is developed
and delivered in small parts (increments) instead of building the complete system at once. Each
increment adds new functionality to the existing software.

Short Explanation

In the incremental process model, the software is not developed in one single step. First, a basic
version of the software is created with limited features. After that, new features are added step
by step in different increments. Each increment goes through phases like analysis, design, coding,
and testing before delivery.

This model is useful when user requirements are not fully clear at the beginning. Users can start
using the early version of the software and give feedback. Based on this feedback, developers
improve the software in next increments. Because of this, changes are easier to manage and
errors are found early.

Diagram: Incremental Process Model

Key Points / Characteristics (natural writing)

• Software is developed in small functional parts

• Each increment adds new features

• User feedback is taken after every increment

• Testing is done after each stage

• Risk is reduced because development is step by step

Advantages of Incremental Model

• Working software is available early

• Easy to modify requirements

• Errors are detected in early stages

• Better user satisfaction

• Suitable for large projects

Disadvantages of Incremental Model

• Needs good planning at start

• Overall system design must be clear

 • Integration of increments can be difficult

• Not suitable if requirements are fully fixed

Short Conclusion (with small mistakes – student style)

So, incremental process model is very useful because software is build slowly and improved time
to time. User get software early and changes are easy to do. Because of this reason, it is widely
used in real projects.

Evolutionary Process Models

Definition

Evolutionary process models are software development models in which the software is
developed in small parts again and again. In this model, software keeps improving step by step
based on user feedback and changing requirements.

Short Explanation

In evolutionary process models, the complete software is not developed at one time. First, a basic
working version is created. After that, new features are added and existing features are improved
in multiple cycles. This model is very useful when user requirements are not clear at the beginning
or change frequently.

This model focuses more on continuous improvement rather than fixed planning. Developers and
users work together regularly, so errors are found early and software quality becomes better with
time.

Types of Evolutionary Process Models

Some common types are:

• Prototyping Model

• Spiral Model

• Concurrent Development Model

These models allow flexibility and user interaction during development.

Characteristics of Evolutionary Models

• Software is developed in iterations

• User feedback is taken regularly

• Easy to handle changing requirements

• Early working version is available

• Risk is reduced step by step

Advantages

• Suitable when requirements are not clear

• Early delivery of working software

• User involvement is high

• Errors are detected early

• Software quality improves gradually

Disadvantages

• Difficult to manage large projects

• Needs continuous user involvement

• Proper planning is required at each stage

• May increase development time

Diagram: Evolutionary Process Model

Example (Simple)

Mobile apps are developed using evolutionary models. First version has basic features, then
updates are released to fix bugs and add new features based on user reviews.

Short Conclusion (with small mistake)

Evolutionary process models are very useful when software need to change again and again. It
gives better product but sometimes planning become little hard.

The Unified Process (UP)

Definition

The Unified Process is a software development process model which follows an iterative and
incremental approach. It divides the software development work into small cycles and develops
the system step by step instead of doing everything at once.
Phases of Unified Process

1. Inception Phase
In this phase, the basic idea of the software is identified. Main requirements and project
scope are decided.

2. Elaboration Phase
System design is improved and major risks are removed. Architecture of software is
prepared here.

3. Construction Phase
Actual coding and development of software is done. Most features are implemented in
this phase.

4. Transition Phase
Software is delivered to users. Testing, deployment, and user feedback is taken.
Characteristics of Unified Process

• Iterative and incremental model

• Risk-driven approach

• Focus on user requirements

• Supports object-oriented development

• Testing is done throughout the process

Advantages of Unified Process

• Errors are found early

• Flexible to requirement changes

• Better risk management

• Suitable for large projects

Disadvantages of Unified Process

• More complex to manage

• Requires skilled team

• Not suitable for very small projects

Example

If a college management system is developed using Unified Process, first only basic features like
login and student record are made. Later, more features like attendance, marks, and reports
are added step by step in different iterations.
Agility Principles

Definition

Agility principles are basic rules followed in agile software development. These principles focus
on flexibility, quick response to change, and continuous improvement while developing software.

Short Explanation

Agility principles say that software should be developed in small parts and improved step by step.
Instead of planning everything at once, developers work in short cycles and take regular feedback
from customers. This helps in making changes easily when requirements change. Agile principles
also focus more on people, communication, and working software rather than heavy
documentation.

Agility allows teams to deliver software faster and with better quality. It helps developers handle
changing customer needs without restarting the whole project.

Main Agility Principles (points)

• Customer satisfaction is given top priority

• Changes in requirements are accepted even late

• Working software is delivered frequently

• Team members and customers work together regularly

• Simplicity and flexibility are important

Example

If a mobile app is developed using agile principles, developers release a basic version first and
then keep adding new features based on user feedback. This makes the app better over time.

Short Conclusion (with small mistake as told)

Agility principles help developer to make software fast and flexible. It is very useful when
requirement not fixed from start.
Simple Diagram (Agile Cycle)

Agile Methods

Agile methods are software development approaches that focus on flexibility, customer
feedback, and fast delivery. Instead of completing the whole software at once, agile methods
divide work into small parts and improve the product step by step. These methods are useful
when requirements change frequently.

Agile methods encourage teamwork, regular communication with the customer, and continuous
testing. Each method follows agile principles but works in its own way depending on project
needs.

Common Agile Methods

1. Scrum
Scrum is the most widely used agile method. In this method, work is divided into short cycles
called sprints (usually 2–4 weeks). After each sprint, a working part of the software is delivered.
Daily meetings help the team track progress and solve problems quickly.
2. Extreme Programming (XP)
Extreme Programming focuses on writing high-quality code. It uses practices like pair
programming, continuous testing, and frequent releases. XP is helpful when requirements change
very often and code quality is very important.

3. Kanban
Kanban is a visual agile method. Work is shown using boards with columns like To Do, In Progress,
and Done. It helps teams manage workflow and reduce overload by limiting work in progress.

4. Lean Software Development

Lean focuses on reducing waste and delivering only what is necessary. It improves efficiency by
avoiding unnecessary features and activities.

5. Crystal Method
Crystal method is flexible and depends on team size and project type. It gives more importance
to people and communication rather than strict rules.

Conclusion (short & human-like, with small mistake)

Agile methods help teams to work fast and handle changes easily. Different agile methods are
used based on project needs, but main aim is always better software and customer satisfaction.

Plan-driven and Agile Development

Definition

Plan-driven development is a software development approach where everything is planned in

advance before actual development starts. Agile development is a flexible approach where
planning, development, and changes happen continuously during the project.

Short Explanation

In plan-driven development, the complete project plan is prepared at the beginning.

Requirements are fixed, design is done once, and then development follows step by step. Changes
are difficult to handle because everything depends on the initial plan. This model is useful when
requirements are very clear and stable.
In agile development, work is done in small parts and software is delivered step by step.
Requirements can change anytime based on customer feedback. Developers focus more on
working software, quick updates, and customer satisfaction instead of heavy documentation.

Key Differences (natural points)

• Plan-driven follows strict planning, agile follows flexible planning

• Plan-driven resists changes, agile accepts changes easily

• Agile gives faster delivery compared to plan-driven

• Plan-driven suits large and stable projects, agile suits dynamic projects

Diagram (important for exam)

Example
Banking software usually follows a plan-driven approach because rules do not change often.
Mobile apps follow agile development because features change frequently based on user
feedback.

Short Conclusion (with small human mistake)

So overall, plan-driven is good when work is fixed, but agile is better when changes comes again
and again and customer want fast result.

Extreme Programming (XP)

Definition

Extreme Programming (XP) is an agile software development method which focuses on customer
satisfaction, continuous feedback, and high-quality code. It follows short development cycles and
frequent releases.

Short Explanation

Extreme Programming is used when requirements change very fast. In XP, developers work closely
with customers and take regular feedback. Coding, testing, and integration happen again and
again in small steps. This helps to reduce errors and improve software quality.

XP gives more importance to teamwork, communication, and simplicity. Developers write simple
code first and improve it later. Testing is done continuously, so bugs are found early. Because of
this, XP is very useful for small and medium projects.

Key Practices / Methods in XP

• Pair programming

• Continuous testing

• Small releases

• Simple design

• Customer involvement
Example

If a mobile app is being developed and user requirements change every week, XP helps
developers to update features quickly by taking regular feedback and testing code frequently.

Scrum

Definition

Scrum is an agile software development framework used to manage and complete complex
projects. It helps teams work together in small steps and deliver software quickly.

Short Explanation

Scrum focuses on breaking work into small parts called sprints, usually of 2 to 4 weeks. In each
sprint, the team plans the work, develops features, tests them, and delivers a working product.
Scrum encourages regular communication, teamwork, and fast feedback so problems can be fixed
early.

Scrum is mostly used when requirements change frequently. Instead of planning everything at
once, Scrum allows teams to improve the product step by step. This makes development flexible
and customer-focused.
Key Elements of Scrum

• Product Owner – decides what features are needed

• Scrum Master – guides the team and removes problems

• Development Team – builds the software

• Sprint – short development cycle

• Daily Scrum – short daily meeting

Example

A mobile app company uses Scrum to release new features every two weeks. After each sprint,
users give feedback and the team improves the app in the next sprint.

Short Conclusion (with small student-type mistake)

Scrum helps team to work fast and better. It is very useful when changes are coming again and
again and product need regular improvement.

Scrum Diagram (for exam – image form)

A Tool Set for the Agile Process

Definition

A tool set for the Agile process means the collection of software tools that help teams to plan,
manage, track, and improve Agile projects easily. These tools support teamwork, fast delivery,
and continuous improvement.

Short Explanation

In Agile development, work is done in small iterations and teams need constant communication
and tracking. Agile tools help developers, testers, and managers to work together smoothly. These
tools make it easy to track tasks, manage user stories, find bugs, and monitor progress. Without
proper tools, Agile process can become confusing and slow.

Main Tools Used in Agile (simple points)

• Project management tools – Used to plan sprints and track tasks

(example: Jira, Trello)

• Version control tools – Used to manage code changes safely

(example: Git)
 • Testing tools – Used for automatic and manual testing
(example: Selenium)

• Continuous integration tools – Used to build and test code regularly

(example: Jenkins)

• Communication tools – Used for team discussion and meetings

(example: Slack)

Example

In a Scrum team, Jira is used to manage sprint tasks, Git is used to store code, and Jenkins is used
to test the code automatically after every update. This makes Agile development fast and
organized.

Short Conclusion (with small mistakes, like average student )

Agile tool set is very important for agile process because it make work easy and fast. Without
tools team cannot manage work properly and project may fail.