Unit 1: Software Engineering and SDLC Models

Introduction to Software Engineering

What is Software Engineering?
Software Engineering is the systematic, disciplined, and quantifiable approach to the
development, operation, and maintenance of software. It applies engineering principles to
software development to manage complexity, ensure reliability, and meet customer
expectations within cost and time constraints.

Key Highlights:

• Application of structured processes and methodologies.

• Focus on product quality and standards compliance.
• Emphasis on managing project scope, cost, time, and resources.
• Techniques to handle complexity and rapidly changing requirements.
• Adopts documentation, modularity, reuse, validation, verification, and
maintenance practices.

History of Software Engineering

• 1968 NATO Conference (Garmisch, Germany): The term ‘Software Engineering’ was
coined.
• 1970s–1980s: Structured programming, Waterfall model, and SDLC practices
emerged.
• 1990s: Introduction of Object-Oriented Programming (OOP), Rational Unified
Process (RUP), CASE tools.
• 2000s–present: Agile methodologies, DevOps, CI/CD.

The Software Crisis

Definition: A situation during the 1960s–70s when most software projects failed to deliver
on time, within budget, and with acceptable quality.

Main Issues:

• Missed deadlines.
• Budget overruns.
• Poor product quality.
• Inadequate documentation.
• Difficult maintenance.

Causes:
 • Rapid hardware advances outpacing software development.
• Lack of structured processes.
• Rising project complexity.
• Evolving and unclear requirements.

Solution:

Software Engineering principles — systematic methodologies, SDLC models, validation

techniques, risk management.

Evolution of a Programming System Product

Term Explanation
Program A set of instructions solving a specific problem.
Programming A program with proper documentation, reusable, tested, and
Product maintainable.
An integrated system combining multiple programming products,
Programming
modular, scalable, reusable, with support and user
System Product
documentation.
Example:

Basic Calculator Program → GUI-based Calculator App → Full-featured Accounting Software

Characteristics of Software
Characteristic Description
Intangibility Software cannot be touched physically — it’s conceptual.
Flexibility Can be modified, upgraded even after deployment.
Reusability Modules/components can be reused in other systems.
Can run on various hardware or operating systems with minimal
Portability
changes.
Complexity High due to intricate logic, control flows, data dependencies.
Maintenance- Requires regular updates, enhancements, and bug fixes post-
Driven deployment.

Brooks’ No Silver Bullet

Fred Brooks’ famous 1987 paper “No Silver Bullet: Essence and Accident in Software
Engineering” declared no single technology, methodology, or management technique
would dramatically improve software productivity, reliability, or simplicity.

Key Points:

• Software’s inherent complexity and flexibility make it difficult.

 • No “silver bullet” breakthrough would solve all problems at once.
• Emphasized incremental, realistic improvements.
• Focus on better tools, processes, and disciplined methodologies.

Software Myths and Realities

Myth Reality
Customers know what they want Requirements evolve during development.
Software can be built perfectly the first
Iterative refinement is essential.
time
Adding more programmers speeds up the
Can delay it (Brooks’ Law).
project
60–70% of total effort is in maintenance and
Once delivered, software is complete
updates.

The Software Development Process

A systematic series of stages for creating software.

Phases:

1. Requirements Gathering
2. Feasibility Study
3. System Design
o High-Level Design (HLD)

Detailed Design (LLD)

4. Coding/Implementation
5. Testing
6. Deployment
7. Maintenance

What is SDLC?
Software Development Life Cycle (SDLC) is a structured, conceptual framework that
outlines all the phases involved in the creation of software — from planning and
requirement gathering to development, testing, deployment, and eventual retirement.
It ensures that software is delivered systematically, efficiently, and with minimal
errors.
Traditional SDLC Models
These are older, structured approaches — mostly used in the early days of software
engineering, where strict documentation, predictability, and formal processes were
emphasized.

1 Waterfall Model
Structure:
A linear, sequential model where progress flows in one direction — like a waterfall —
through a series of fixed phases:
1. Requirements Gathering
2. System Design
3. Implementation
4. Testing
5. Deployment
6. Maintenance
Characteristics:
• Each phase must be completed before the next begins.
• No overlap between phases.
Advantages:
• Simple, easy to understand.
• Clearly defined stages and deliverables.
• Works well for projects with well-understood, fixed requirements.
• Thorough documentation at each phase.
Disadvantages:
• Very inflexible.
• Late discovery of errors, often during testing.
• Poor at accommodating change — changes at later stages are costly.
• Not suitable for complex or dynamic projects.
Use Case:
Good for small projects or projects with well-defined, unchanging requirements
(e.g., payroll systems in the early 90s).

2 Iterative/Incremental Model
Structure:
Software is developed in increments or versions. Each increment adds new
functionalities.
Working:
• Initial planning
 • Iterative design, coding, and testing of small modules
• Deliver partial systems early and gradually build up
Advantages:
• Early delivery of working software.
• Easier debugging — errors found and fixed in increments.
• Customer feedback integrated early.
• Better risk management compared to Waterfall.
Disadvantages:
• Requires a modular system design.
• Can have management overhead in tracking multiple increments.
• Not all requirements known at the beginning.
Use Case:
Medium to large projects where requirements evolve (e.g., enterprise applications,
CRM systems).

3 Prototyping Model
Approach:
Quickly build a prototype (an incomplete but functional application), gather user
feedback, and then refine.
Steps:
1. Quick design
2. Prototype building
3. User evaluation
4. Prototype refinement
5. Final system development
Advantages:
• Improved user involvement.
• Early detection of misunderstandings and requirement mismatches.
• Reduces risk of final system failure.
Disadvantages:
• Users may mistake the prototype for the final system.
• Can lead to poor design practices if developers focus only on fast prototyping.
• May increase project scope.
Use Case:
Projects with unclear requirements (e.g., custom dashboards, mobile apps with novel
interfaces).
4 Spiral Model
Structure:
Combines iterative development with systematic risk analysis.
Phases (per spiral iteration):
1. Planning
2. Risk Analysis
3. Engineering
4. Customer Evaluation
Each loop represents a phase or refinement.
Advantages:
• Excellent for high-risk, complex projects.
• Continuous refinement via iterations.
• Risks identified and mitigated early.
• Flexible to changes.
Disadvantages:
• Requires expertise in risk analysis.
• Can be complex and expensive.
• Not suitable for small, low-risk projects.
Use Case:
Large defense, banking, or medical systems where safety and reliability are critical.

5 V-Model (Verification and Validation Model)

Structure:
An extension of the Waterfall model where each development phase has a
corresponding testing phase in parallel.
Stages:
• Requirements → Acceptance Testing
• System Design → System Testing
• Detailed Design → Integration Testing
• Coding → Unit Testing
Advantages:
• Early defect detection during corresponding test phases.
• Structured and disciplined.
• Clear relationships between development and testing phases.
Disadvantages:
• Still inflexible like Waterfall.
• No prototypes or intermediate builds.
• Not ideal for dynamic projects.
Use Case:
Safety-critical systems like aviation software, embedded systems, automotive control
software.

6 Rapid Application Development (RAD)

Approach:
Emphasizes rapid prototyping, fast feedback, and the use of CASE tools (Computer-
Aided Software Engineering).
Key Features:
• Component-based construction.
• Minimal planning — focus on rapid delivery.
• Users involved continuously.
Advantages:
• High speed and flexibility.
• Heavy user involvement.
• Can quickly adapt to requirement changes.
Disadvantages:
• Requires skilled developers.
• Not suitable for complex or performance-sensitive applications.
• Dependent on availability of reusable components and CASE tools.
Use Case:
Tight deadline business applications, UI-heavy systems.

Agile SDLC Models

Modern, adaptive frameworks focused on collaboration, customer feedback, and
iterative releases.

Agile Model
Structure:
• Incremental and iterative.
• Requirements and solutions evolve via collaboration between cross-
functional teams and users.
Principles: (from Agile Manifesto)
• Adaptive planning.
• Continuous delivery.
• Customer collaboration over contract negotiation.
• Responding to change over following a plan.
Advantages:
• Highly flexible and adaptive.
• Faster value delivery.
• Frequent feedback improves product-market fit.
• Reduced risks of late-stage failures.
Disadvantages:
• Requires experienced, self-organizing teams.
• Can face issues in fixed-budget projects.
• Less documentation compared to traditional models.
Use Case:
Startups, web applications, SaaS products, rapidly evolving projects.

Scrum
Structure:
An Agile framework breaking work into time-boxed iterations called Sprints (usually
2–4 weeks).
Key Elements:
• Product Backlog: List of features/requirements.
• Sprint Planning: Selecting work for the next sprint.
• Daily Standup Meetings: Quick team sync-ups.
• Sprint Review & Retrospective: At the end of each sprint.
Advantages:
• Fast, regular delivery of usable software.
• Strong emphasis on teamwork and communication.
• Frequent customer feedback integration.
Disadvantages:
• Scope creep risk if the product backlog isn’t well managed.
• Requires high team discipline and experience.
• Can be chaotic without proper Scrum Master guidance.
Use Case:
Small to medium Agile teams developing dynamic, feature-rich products.

Non-Traditional SDLC Models

These are modern methodologies or hybrids of traditional models tailored for object-
oriented, enterprise, or component-based systems.
Rational Unified Process (RUP)
Approach:
An iterative, object-oriented SDLC model created by Rational (now part of IBM).
Phases:
1. Inception: Define business case and scope.
2. Elaboration: Detailed requirement and risk analysis.
3. Construction: Build and test software.
4. Transition: Deploy to users.
Key Features:
• Emphasizes use case-driven development.
• Focus on architecture first.
• Iterative and incremental.
Advantages:
• Well-documented and controlled.
• Scalable for large projects.
• Risk managed early.
Disadvantages:
• Complex and heavyweight.
• Expensive to implement.
• Requires trained teams.
Use Case:
Large enterprise systems, government contracts.

Modern RAD
Use Cases:
• Tight deadlines
• Dynamic requirement changes
Examples:
• Oracle Developer Suite
• Microsoft Visual Studio (especially with tools like Windows Forms, ASP.NET)
Key Characteristics:
• Component reuse.
• Prebuilt frameworks.
• GUI-based development.
• Less coding, more assembling.
Advantages:
• High productivity.
• Shortened development cycle.
Disadvantages:
• May compromise software architecture quality.
• Relies on availability of quality reusable components.
Use Case:
Enterprise applications, database-driven business software.

Comparison Table
Feedback Project
Model Flexibility Risk Handling
Speed Suitability
Small, static
Waterfall Low Poor Late
projects
Medium,
Iterative Medium Moderate Early
dynamic
Unclear
Prototyping High Good Early
requirements
High-risk,
Spiral High Excellent Early
complex
Early (in testing
V-Model Low Good Safety-critical
phases)
Fast-paced
RAD High Moderate Very Fast
business apps
Dynamic
Agile Very High Good Continuous
startups, SaaS
Agile teams,
Scrum Very High Good Very Fast
new products
Large
RUP Medium Excellent Early enterprise
systems
GUI-heavy,
Modern RAD High Moderate Very Fast tight-deadline
apps

Detailed SDLC Models Comparison

Waterfall vs. Iterative
Criteria Waterfall Iterative
Approach Linear and sequential Incremental and iterative
Flexibility Low High
Risk Handling Low Medium
Documentation High Medium
Agile vs. Traditional
Criteria Agile Traditional
Approach Incremental Linear and sequential
Flexibility High Low
Risk Handling Medium Low
Documentation Low High

Advantages and Disadvantages of SDLC Models

Advantages
• Improved Quality
• Reduced Costs
• Increased Productivity

Disadvantages
• Inflexibility
• High Documentation

SDLC Models in Real-World Scenarios

Example 1: Waterfall
• Banking system with high security and reliability.

Example 2: Agile
• Mobile app requiring flexibility and rapid delivery.

Best Practices for SDLC Models

1. Choose the Right Model
2. Define Clear Requirements
3. Establish a Strong Team
4. Monitor and Control Progress

Diagrams
Waterfall Model Diagram
+-------------------+
| Requirements |
+-------------------+
|
|
v
+-------------------+
| Design |
+-------------------+
|
|
v
+-------------------+
| Implementation |
+-------------------+
|
|
v
+-------------------+
| Testing |
+-------------------+
|
|
v
+-------------------+
| Deployment |
+-------------------+
|
|
v
+-------------------+
| Maintenance |
+-------------------+

Iterative Model Diagram

+-------------------+
| Requirements |
+-------------------+
|
|
v
+-------------------+
| Design |
+-------------------+
|
|
v
+-------------------+
| Implementation |
+-------------------+
|
|
v
+-------------------+
| Testing |
+-------------------+
|
|
v
+-------------------+
| Deployment |
+-------------------+
|
|
v
+-------------------+
| Maintenance |
+-------------------+
|
|
v
+-------------------+
| Iteration |
+-------------------+

Agile Model Diagram

+-------------------+
| Requirements |
+-------------------+
|
|
 v
+-------------------+
| Sprint Planning |
+-------------------+
|
|
v
+-------------------+
| Development |
+-------------------+
|
|
v
+-------------------+
| Testing |
+-------------------+
|
|
v
+-------------------+
| Review and |
| Retrospective |
+-------------------+
|
|
v
+-------------------+
| Iteration |
+-------------------+

The following diagrams illustrate the SDLC models.

Waterfall Model Diagram

+-------------------+
| Requirements |
+-------------------+
|
|
v
+-------------------+
| Design |
+-------------------+
|
|
v
+-------------------+
| Implementation |
+-------------------+
|
|
v
+-------------------+
| Testing |
+-------------------+
|
|
v
+-------------------+
| Deployment |
+-------------------+
|
|
v
+-------------------+
| Maintenance |
+-------------------+

Iterative Model Diagram

+-------------------+
| Requirements |
+-------------------+
|
|
v
+-------------------+
| Design |
+-------------------+
|
|
v
+-------------------+
| Implementation |
+-------------------+
|
|
v
+-------------------+
| Testing |
+-------------------+
|
|
v
+-------------------+
| Deployment |
+-------------------+
|
|
v
+-------------------+
| Maintenance |
+-------------------+
|
|
v
+-------------------+
| Iteration |
+-------------------+

Agile Model Diagram

+-------------------+
| Requirements |
+-------------------+
|
|
v
+-------------------+
| Sprint Planning |
+-------------------+
|
|
 v
+-------------------+
| Development |
+-------------------+
|
|
v
+-------------------+
| Testing |
+-------------------+
|
|
v
+-------------------+
| Review and |
| Retrospective |
+-------------------+
|
|
v
+-------------------+
| Iteration |
+-------------------+

References
• Brooks, F. P. (1987). No silver bullet: Essence and accidents of software engineering.
Computer, 20(4), 10-19.
• Sommerville, I. (2011). Software engineering. Pearson Education.
• Pressman, R. S. (2010). Software engineering: A practitioner’s approach. McGraw-
Hill.