Home › CSE Hub › Software Engineering

Software Engineering

The software development life cycle, process models from Waterfall to Agile and Scrum, requirements, UML design, testing levels and techniques, Git and DevOps basics.

हिंदी में: बड़े सॉफ़्टवेयर को योजना के साथ बनाने, टेस्ट करने और संभालने की इंजीनियरिंग।

What is software engineering?

Software engineering is the systematic, disciplined approach to developing, operating and maintaining software. It treats software like any engineering product: plan it, design it, build it, test it, and keep improving it.

Software Development Life Cycle (SDLC)

  1. Requirement analysis – understand what users need; write the SRS (Software Requirements Specification).
  2. Design – architecture, modules, database and interface design.
  3. Implementation – write the code.
  4. Testing – find and fix defects.
  5. Deployment – release to users.
  6. Maintenance – corrective (bug fixes), adaptive (new environments), perfective (improvements) and preventive.

Process models

Model Idea Best for
Waterfall Phases happen one after another Small projects with fixed, clear requirements
V-model Each development phase has a matching test phase Safety-critical projects
Incremental Deliver the system in working pieces Early partial releases
Prototype Build a quick model to clarify requirements Unclear requirements
Spiral Iterations driven by risk analysis Large, high-risk projects
Agile Short iterations, continuous feedback Changing requirements, most modern teams

Agile and Scrum

Agile values individuals and interactions, working software, customer collaboration and responding to change. In Scrum, work happens in short sprints (usually 1–4 weeks). Roles: Product Owner, Scrum Master, Developers. Events: sprint planning, daily scrum, sprint review, retrospective. Artifacts: product backlog, sprint backlog, increment.

Requirements

  • Functional requirements – what the system must do (e.g. “users can reset their password”).
  • Non-functional requirements – qualities such as performance, security, usability, reliability and scalability.

Design principles

  • High cohesion, low coupling – each module does one job well and depends little on others.
  • SOLID – Single responsibility, Open/closed, Liskov substitution, Interface segregation, Dependency inversion.
  • DRY (Don’t Repeat Yourself) and KISS (Keep It Simple).
  • Design patterns – reusable solutions such as Singleton, Factory, Observer, Strategy and MVC.

UML diagrams

  • Structural: class, object, component, deployment diagrams.
  • Behavioural: use-case, sequence, activity, state diagrams.

Testing

Levels: unit → integration → system → acceptance (UAT).

Technique What it checks
Black-box Behaviour against requirements, without looking at code (equivalence partitioning, boundary value analysis)
White-box Internal logic and paths (statement, branch and path coverage)
Regression Old features still work after a change
Performance / load Speed and stability under load

Verification asks “are we building the product right?”; validation asks “are we building the right product?”

Estimation and metrics

  • COCOMO estimates effort from size in KLOC (thousands of lines of code).
  • Function points measure size from inputs, outputs, inquiries, files and interfaces.
  • Cyclomatic complexity = E − N + 2P measures the number of independent paths through code.

Version control, CI/CD and DevOps

  • Git tracks changes: git init, add, commit, branch, merge, push, pull.
  • CI (Continuous Integration) – every change is automatically built and tested.
  • CD (Continuous Delivery/Deployment) – tested changes are released automatically or with one click.
  • DevOps brings development and operations together using automation, monitoring and fast feedback.

Quick revision

  • SDLC: requirements → design → code → test → deploy → maintain.
  • Waterfall for fixed requirements; Agile for changing ones.
  • Aim for high cohesion and low coupling.
  • Black-box tests behaviour; white-box tests internal logic.