Module I

Introduction to Software
Engineering and Process
Models
Software is a collection of instructions, data, or computer programs that are
used to run machines and carry out particular activities. It is the antithesis
of hardware, which refers to a computer's external components. A device's
running programs, scripts, and applications are collectively referred to as
"software" in this context.
What is a Software?
In a computer system, the software is basically a set of instructions or
commands that tell a computer what to do. In other words, the software is a
computer program that provides a set of instructions to execute a user’s
commands and tell the computer what to do. For example like MS-
Word, MS-Excel, PowerPoint, etc.
Types of Software
It is a collection of data that is given to the computer to complete a particular
task. The chart below describes the types of software:
Above is the diagram of types of software. Now we will briefly describe each
type and its subtypes:
1. System Software
• Operating System
• Language Processor
• Device Driver
2. Application Software
• General Purpose Software
• Customize Software
• Utility Software
System Software
System software is software that directly operates the computer
hardware and provides the basic functionality to the users as well as to the
other software to operate smoothly. Or in other words, system software
basically controls a computer’s internal functioning and also controls
hardware devices such as monitors, printers, and storage devices, etc. It is
like an interface between hardware and user applications, it helps them to
communicate with each other because hardware understands machine
language(i.e. 1 or 0) whereas user applications are work in human-readable
languages like English, Hindi, German, etc. so system software converts the
human-readable language into machine language and vice versa.
Types of System Software
It has two subtypes which are:
1. Operating System: It is the main program of a computer system.
When the computer system ON it is the first software that loads into
the computer's memory. Basically, it manages all the resources such
as computer memory, CPU, printer, hard disk, etc., and provides an
interface to the user, which helps the user to interact with the
computer system. It also provides various services to other computer
software. Examples of operating systems are Linux, Apple
macOS, Microsoft Windows, etc.
2. Language Processor: As we know that system software converts the
human-readable language into a machine language and vice versa.
So, the conversion is done by the language processor. It converts
programs written in high-level programming
languages like Java, C, C++, Python, etc(known as source code), into
sets of instructions that are easily readable by machines(known as
object code or machine code).
3. Device Driver: A device driver is a program or software that controls a
device and helps that device to perform its functions. Every device like
a printer, mouse, modem, etc. needs a driver to connect with the
computer system eternally. So, when you connect a new device with
 your computer system, first you need to install the driver of that device
so that your operating system knows how to control or manage that
device.
What is Software Engineering?
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.
1. Software engineering includes a variety of techniques, tools, and
methodologies, including requirements analysis, design, testing, and
maintenance.
2. It is a rapidly evolving field, and new tools and technologies are
constantly being developed to improve the software development
process.
3. 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.
4. Software Engineering is mainly used for large projects based on
software systems rather than single programs or applications.
5. The main goal of Software Engineering is to develop software
applications for improving quality, budget, and time efficiency.
6. Software Engineering ensures that the software that has to be built
should be consistent, correct, also on budget, on time, and within the
required requirements.
Key Principles of Software Engineering
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.
Main Attributes of Software Engineering
Software Engineering is a systematic, disciplined, quantifiable study and
approach to the design, development, operation, and maintenance of a
software system. There are four main Attributes of Software Engineering.
1. Efficiency: It provides a measure of the resource requirement of a
software product efficiently.
2. Reliability: It assures that the product will deliver the same results
when used in similar working environment.
3. Reusability: This attribute makes sure that the module can be used in
multiple applications.
 4. Maintainability: It is the ability of the software to be modified,
repaired, or enhanced easily with changing 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 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 concerning 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.
What Tasks do Software Engineers do?
The main responsibility of a software engineer is to develop useful computer
programs and applications. Working in teams, you would complete various
projects and develop solutions to satisfy certain customer or corporate
demands.
Some of the key responsibilities of software engineer are:
 • Requirement Analysis: Collaborating with stakeholders to
understand and gather the requirements to design and develop
software solutions.
• Design and Development: Creating well-structured, maintainable
code that meets the functional requirements and adheres to software
design principles.
• Testing and Debugging: Writing and conducting unit tests, integration
tests, and debugging code to ensure software is reliable and bug-free.
• Code Review: Participating in code reviews to improve code quality,
ensure adherence to standards, and facilitate knowledge sharing
among team members.
• Maintenance: Updating and maintaining existing software systems,
fixing bugs, and improving performance or adding new features.
• Documentation: Writing clear documentation, including code
comments, API documentation, and design documents to help other
engineers and future developers understand the system.

What are Software Processes?

Software processes in software engineering serve as the foundational
framework for designing, developing, testing, and maintaining software
systems efficiently. These structured methodologies provide a systematic
approach, ensuring organized project management, clear communication,
and high-quality output. They orchestrate the complex journey of turning
concepts into functional digital realities, enhancing collaboration, reducing
uncertainties, and optimizing resource allocation from inception through
deployment and beyond.
Common models, including Waterfall, Agile, and DevOps methodologies,
offer different perspectives to customize and refine these processes,
aligning them with project intricacies. DevOps, for example, integrates
development and operations, promoting continuous integration and
delivery. The interplay of these methodologies forms the core of efficient
software craftsmanship, nurturing teamwork and yielding
sophisticated, forward-looking outcomes amid the ever-evolving
technological landscape.

Software processes in software engineering refer to the methods and

techniques used to develop and maintain software. Some examples of
software processes include:
• Waterfall: a linear, sequential approach to software development,
with distinct phases such as requirements gathering, design,
implementation, testing, and maintenance.
• Agile: a flexible, iterative approach to software development, with an
emphasis on rapid prototyping and continuous delivery.
• Scrum: a popular Agile methodology that emphasizes teamwork,
iterative development, and a flexible, adaptive approach to planning
and management.
• DevOps: a set of practices that aims to improve collaboration and
communication between development and operations teams, with an
emphasis on automating the software delivery process.
Software Development Life Cycle (SDLC) (Very Important)
SDLC is a systematic process used by software developers and engineers to
design, develop, test, and maintain software.
It provides a structured framework for planning and controlling the
development of an information system.
Phases of SDLC
There are typically 6 to 7 standard phases in SDLC:

1. Requirement Gathering & Analysis

• Understand what the client/user wants.
• Analysts gather functional (what the system should do) and non-
functional (performance, security, etc.) requirements.
• Conduct feasibility study (technical, economic, legal, operational).
Output: SRS (Software Requirements Specification) document
Real-life,Example:
Client wants an online food delivery app. Requirements like login, order
placement, payment, delivery tracking are gathered.

2. System Design
• Design the architecture based on SRS.
• Create Data Flow Diagrams (DFD), Entity Relationship Diagrams
(ERD), database schemas, etc.
• Interface, modules, and database design are finalized.
Output: Design Document
Real-life,Example:
For the food app, decide UI screens (home, cart, menu), backend APIs, and
database for users, orders, restaurants.
3. Implementation / Coding
• Developers write code based on the design.
• Use programming languages like Java, Python, C#, etc.
• Follow coding standards and version control.
Output: Working software module
Real-life,Example:
Develop login system, connect to database, write APIs to fetch food items,
calculate total, etc.

4. Testing
• Test the software for bugs, performance, and functionality.
• Types: Unit Testing, Integration Testing, System Testing, Acceptance
Testing.
Output: Tested software with bug reports
Real-life,Example:
Check if the payment gateway works, invalid inputs handled, food items
display correctly, etc.

5. Deployment
• The tested product is delivered to users.
• Done in stages: beta release, full deployment.
• Deploy on cloud or server infrastructure.
Output: Live product
Real-life,Example:
The food app is deployed on Play Store and cloud servers for user access.
6. Maintenance
• Fix bugs reported by users.
• Add new features based on feedback.
• Update software to adapt to new technologies.
Output: Updated and maintained software
Real-life,Example:
Add live delivery tracking, loyalty points, or remove glitches during peak
hours.

Optional Phase: Planning

• Before all steps, a detailed plan is created:
o Resource allocation
o Timeline estimation
o Risk assessment

Popular SDLC Models

Model Description Suitable For

Small projects with clear

Waterfall Linear, step-by-step
requirements

Testing is planned in
V-Model Critical systems
parallel

Software built in small

Incremental Projects with partial requirements
parts

Repeat development in
Iterative Projects needing flexibility
cycles

Spiral Risk-driven, iterative High-risk, large projects

Model Description Suitable For

Agile Adaptive, short sprints Changing requirements

Advantages of SDLC

• Clear project goals and timelines

• Helps track progress and costs
• Reduces risk and ensures quality
• Standardizes software development

Disadvantages
• Can be rigid in traditional models (e.g., Waterfall)
• Requires a lot of documentation
• Time-consuming if not managed properly

Example: SDLC in a Real Project

Project: Building a mobile banking app

• Requirement: Users want to check balance, transfer money, pay

bills.

• Design: UI mockups, database for accounts and transactions

• Development: Use React Native for app, [Link] for backend

• Testing: Check transaction failures, invalid login, etc.

• Deployment: Release on App Store

• Maintenance: Add features like QR code payments, chat support.

Prescriptive Process Models (Very Important)
Prescriptive process models prescribe a specific set of activities, tasks, and
milestones for software development. They emphasize thorough planning,
defined phases, and control mechanisms.
1. Waterfall Model
Definition: A linear and sequential approach where each phase must be
completed before the next begins.
Phases:
1. Requirements Analysis
o Gather functional and non-functional requirements
o Create Software Requirements Specification (SRS)
2. System Design
o Architectural design, high-level and detailed design
o Data models, interface specifications
3. Implementation (Coding)
o Translate design into code modules
o Follow coding standards
4. Integration & Testing
o Unit testing, integration testing, system testing, acceptance
testing
o Record and fix defects
 5. Deployment
o Release software to production environment
o User training and documentation
6. Maintenance
o Bug fixes, updates, enhancements
Advantages:
• Simple to understand and use
• Well-defined milestones and deliverables
• Works well for small, well-understood projects
Disadvantages:
• Inflexible to changes once a phase is complete
• Late discovery of design or requirement flaws
• High risk and uncertainty
Real-life Example: Banking ATM software with fixed requirements and
regulatory compliance.
2. Incremental Model
Definition: Builds the system in small, usable increments. Each increment
adds functionality until the full system is delivered.

Phases (per increment):

1. Planning & Requirements for Increment
o Prioritize and select a subset of requirements
2. Design & Implementation
o Design modules for chosen requirements
o Code and integrate
3. Testing
o Test the new increment both standalone and integrated
4. Delivery
o Deploy the increment to users
5. Feedback & Maintenance
o Gather user feedback and handle defects
Advantages:
• Early delivery of core functionality
• Allows user feedback and flexibility
• Lower initial delivery cost
Disadvantages:
• Architecture must support incremental growth
• May incur additional costs due to repeated planning and design cycles
Real-life Example: E-commerce platform launching product browsing and
checkout in separate releases.

3. Evolutionary Process Model

Evolutionary models focus on developing a system through repeated
refinement cycles. Two common variants:
a) Prototyping Model
Definition: Create a quick, throwaway or evolutionary prototype to clarify
requirements before full development.
Steps:
1. Quick Design: Outline the basic system structure.
2. Build Prototype: Develop a simplified version showing key features.
3. User Evaluation: Users interact and provide feedback.
4. Refine Prototype: Improve and expand until a final prototype meets
requirements.
Advantages:
• Clarifies ambiguous requirements
• Engages users early
Disadvantages:
• Risk of prototype becoming final without proper design
• Can lead to feature creep
Example: Custom CRM where user interface and workflows are prototyped
before full implementation.
b) Spiral Model
Definition: Risk-driven model that combines iterative development with
systematic aspects of waterfall.

Cycles (Spirals):
1. Objective Setting: Define goals, alternatives, constraints.
2. Risk Analysis & Reduction: Identify and mitigate risks.
3. Development & Testing: Choose an appropriate model (e.g.,
waterfall) to build an increment.
4. Planning: Review and plan the next cycle.
Advantages:
• Emphasizes risk management
• Flexible and iterative
Disadvantages:
• Can be complex to manage
• Risk assessment requires expertise
Real-life Example: Large defense or aerospace systems with critical risk
considerations.

Comparative Summary

Risk Early Best Suited

Model Approach Flexibility
Management Delivery For

Stable
Waterfall Linear Low Low No requirements,
small scale

Projects
Staged
Incremental Medium Medium Yes needing early
delivery
value

Projects with
Quick Yes
Prototyping High Low unclear
prototype (prototype)
requirements

Iterative, Large, high-

Spiral High High Yes
risk risk projects
Agile Process Model (Important)
Definition: Agile is a mindset and set of practices that emphasize
adaptability, customer collaboration, and rapid delivery of working software
through iterative development.
What is Agility?
• Responsiveness to Change: Ability to respond quickly to evolving
requirements and market conditions.
• Continuous Improvement: Regularly reflecting on processes and
implementing improvements.
• Customer Focus: Involving customers throughout development to
ensure the product meets real needs.
Agile Manifesto (Values):
1. Individuals and interactions over processes and tools
2. Working software over comprehensive documentation
3. Customer collaboration over contract negotiation
4. Responding to change over following a plan
Principles of Agile:
• Satisfy the customer with early and continuous delivery of valuable
software.
• Welcome changing requirements, even late in development.
• Deliver working software frequently, from a couple of weeks to a
couple of months.
• Business people and developers must work together daily.
• Build projects around motivated individuals and trust them.
• Face-to-face conversation is the best form of communication.
• Working software is the primary measure of progress.
• Agile processes promote sustainable development.
 • Continuous attention to technical excellence and good design.
• Simplicity—the art of maximizing work not done—is essential.
• The best architectures, requirements, and designs emerge from self-
organizing teams.
• At regular intervals, the team reflects and adjusts behavior.
Typical Agile Workflow:
1. Sprint Planning: Define sprint goal and backlog items.
2. Sprint Execution: Develop features, hold daily stand-ups.
3. Review & Demo: Showcase working increments to stakeholders.
4. Retrospective: Reflect on the sprint to improve in the next cycle.
Advantages:
• High flexibility and adaptability to change.
• Frequent delivery yields early product validation.
• Enhanced customer engagement and satisfaction.
Disadvantages:
• Requires experienced, self-organizing teams.
• Less predictability in scope and timeline.
• Can be challenging for fixed-price contracts.
Real-life Example: A mobile app startup releases new features every two
weeks based on user feedback, continuously refining the product.
Extreme Programming (XP)
Definition: Extreme Programming (XP) is an Agile methodology focused on
improving software quality and responsiveness to changing customer
requirements through frequent releases in short development cycles.
Goals:
• Enhance software quality
• Improve customer satisfaction
• Reduce risks by rapid feedback and frequent iterations
Roles & Responsibilities:
• Customer (On-site Customer): Defines and prioritizes user stories;
provides continuous feedback.
• Developer: Implements features, writes tests, refactors code;
collaborates through pair programming.
• Coach: Guides the team in XP practices and ensures adherence to
principles.
• Tracker: Monitors progress, collects metrics (velocity, code
coverage).
• Tester: Works closely with developers to write acceptance tests and
ensure product quality.
Key Practices:
1. User Stories & Planning Game:
o Small, clear requirements (stories) estimating effort and value.
o Iteration planning chooses stories based on team velocity and
priority.
2. Test-Driven Development (TDD):
o Write automated unit tests before coding the functionality.
o Refactor code to pass tests and maintain design simplicity.
3. Pair Programming:
o Two developers share one workstation: driver writes code,
navigator reviews.
o Promotes knowledge sharing and immediate code review.
4. Continuous Integration (CI):
o Integrate code changes into the main branch at least once a day.
o Automated build and test pipeline runs on every integration.
5. Refactoring:
o Improve internal code structure without changing external
behavior.
o Regular refactoring keeps the codebase clean and reduces
technical debt.
6. Simple Design:
o Design only for current requirements; avoid speculative
features.
o Follow the YAGNI (“You Aren’t Gonna Need It”) principle.
7. Collective Code Ownership:
o Any team member can modify any part of the code.
o Encourages responsibility and prevents silos.
8. Coding Standards:
o Agree on a common style guide to ensure consistency.
o Automation tools (linters, formatters) enforce standards.
9. Small Releases:
o Deliver working software every 1–3 weeks.
o Each release must pass all acceptance tests.
10. Sustainable Pace (40-hour Week):
 o Avoid overtime to maintain team health and productivity.
Artifacts & Metrics:
• Iteration Backlog: Selected user stories for the current iteration.
• Velocity: Number of story points completed per iteration; used for
planning.
• Test Coverage Reports: Percentage of code exercised by automated
tests.
• Defect Rate: Number and severity of bugs found in releases.
Lifecycle Flow:
1. Release Planning: Customer and team agree on features for the
release.
2. Iteration Cycle: (1–3 weeks)
o Iteration Planning → Development & TDD → Integration →
Iteration Review → Retrospective
3. Release Execution: Multiple iteration cycles culminate in a
deployable release.
Advantages:
• Rapid response to changing requirements.
• High code quality through TDD and refactoring.
• Enhanced communication via pair programming and on-site
customer.
Disadvantages:
• Requires high discipline and skilled practitioners.
• On-site customer availability can be challenging.
• May not scale easily for very large, distributed teams.
Real-life Example: A fintech startup implements an online payment
gateway. Using XP, they plan bi-weekly releases, pair-program critical
payment modules, maintain automated test suites, and involve a dedicated
product owner for continuous feedback, reducing defect rates by 60% after
three iterations.