4 min read
On this page

Software Development Life Cycle Models

The SDLC defines the process for planning, creating, testing, and deploying software. Different models suit different project types.

Waterfall

Sequential phases, each completed before the next begins.

Requirements → Design → Implementation → Testing → Deployment → Maintenance

Advantages: Simple, well-documented, clear milestones. Works for well-understood projects with stable requirements.

Disadvantages: No flexibility for changing requirements. Late discovery of problems. Customer sees the product only at the end.

When to use: Safety-critical systems (avionics, medical devices), regulatory environments, projects with fixed, well-understood requirements.

V-Model

Extension of waterfall. Each development phase has a corresponding testing phase.

Requirements ────────────────── Acceptance Testing
    Design ──────────────── System Testing
        Detailed Design ──── Integration Testing
            Implementation ── Unit Testing

Key insight: Test planning begins early — test cases are designed alongside specifications, not after coding.

Iterative and Incremental

Iterative: Repeat the development cycle, refining the product each iteration.

Incremental: Deliver the system in pieces (increments). Each increment adds functionality.

Increment 1: Core features → deploy
Increment 2: Additional features → deploy
Increment 3: Polish + remaining features → deploy

Advantages: Early delivery of working software. Feedback drives next iteration. Risk reduction.

Spiral Model (Boehm, 1986)

Combines iterative development with risk analysis at each cycle.

Each spiral cycle:
1. Determine objectives, alternatives, constraints
2. Evaluate alternatives, identify and resolve risks
3. Develop and verify the next level
4. Plan the next iteration

Key idea: Focus on risks early. If a risk is too high, stop before investing too much.

Best for: Large, complex, high-risk projects.

Agile

A family of iterative, incremental methodologies emphasizing:

  • Individuals and interactions over processes and tools
  • Working software over comprehensive documentation
  • Customer collaboration over contract negotiation
  • Responding to change over following a plan

Scrum

Roles: Product Owner (what to build), Scrum Master (process facilitation), Development Team (building).

Artifacts: Product Backlog (prioritized feature list), Sprint Backlog (items for this sprint), Increment (working software).

Events:

  • Sprint (2-4 weeks): Fixed time box for development.
  • Sprint Planning: Select items from backlog for the sprint.
  • Daily Standup (15 min): What did I do? What will I do? Any blockers?
  • Sprint Review: Demo working software to stakeholders.
  • Sprint Retrospective: What went well? What to improve?

Velocity: Story points completed per sprint. Used for planning future sprints.

Kanban

Visualize workflow on a board with columns (To Do, In Progress, Review, Done). Limit work in progress (WIP) per column.

| To Do   | In Progress (3) | Review (2) | Done    |
|---------|-----------------|------------|---------|
| Story E | Story B         | Story A    | Story X |
| Story F | Story C         |            | Story Y |
|         | Story D         |            |         |

Pull-based: Work is pulled from the previous column when capacity is available. WIP limits prevent overloading.

No fixed sprints: Continuous flow. Deploy when ready.

Extreme Programming (XP)

Emphasizes technical practices:

  • Pair programming: Two developers at one computer.
  • Test-driven development (TDD): Write tests first.
  • Continuous integration: Integrate and test multiple times per day.
  • Refactoring: Continuously improve code structure.
  • Simple design: YAGNI (You Ain't Gonna Need It).
  • Collective code ownership: Anyone can modify any code.
  • Customer on-site: Immediate feedback.

SAFe (Scaled Agile Framework)

Agile at scale for large organizations. Multiple teams coordinated through:

  • Agile Release Trains (ARTs): Groups of 50-125 people.
  • Program Increments (PIs): 8-12 week planning cycles.
  • Solution Trains: Multiple ARTs for very large systems.

Criticism: Complex, heavyweight, "agile in name only" for some implementations.

DevOps

A culture and set of practices combining development and operations.

Principles:

  • Shared responsibility (dev + ops own the full lifecycle)
  • Automation (CI/CD, infrastructure as code, monitoring)
  • Continuous improvement (feedback loops, blameless postmortems)
  • Measurement (metrics, SLIs/SLOs)

Practices: CI/CD, infrastructure as code, monitoring/alerting, incident management, chaos engineering.

Requirements Engineering

Elicitation

Gathering requirements from stakeholders: interviews, workshops, observation, questionnaires, prototyping, domain analysis.

Analysis

Organize and prioritize requirements. Resolve conflicts. Identify gaps. Feasibility assessment.

Specification

Document requirements. Formats: user stories, use cases, formal specifications, SRS (Software Requirements Specification).

Validation

Ensure requirements are correct, complete, consistent, verifiable, and feasible. Reviews, walkthroughs, prototyping.

User Stories

Format: "As a [role], I want [feature] so that [benefit]."

As a user, I want to reset my password via email so that I can regain access to my account.

INVEST criteria: Independent, Negotiable, Valuable, Estimable, Small, Testable.

Acceptance Criteria

Given-When-Then format:

Given I am on the login page
When I click "Forgot Password" and enter my email
Then I receive a password reset link within 5 minutes
And the link expires after 24 hours

Applications in CS

  • Startups: Agile/Kanban — fast iteration, adapt to market feedback.
  • Enterprise: Scrum with SAFe scaling. Requirements documents for compliance.
  • Open source: Issue-driven development. PRs as the unit of work.
  • Embedded/safety: V-model or waterfall with formal verification. DO-178C (avionics), ISO 26262 (automotive).
  • Platform teams: DevOps culture. SRE practices. Infrastructure as code.