Software Engineering: Principles & Practice

Grade 12 · Technology · Study Guide

A college-prep overview of the SDLC, design principles, testing strategies, and team-based development practices.

Software engineering is the disciplined application of engineering principles to the design, development, testing, and maintenance of software systems. It distinguishes professional software development from informal coding by emphasizing process, documentation, collaboration, and long-term maintainability. The Software Development Life Cycle (SDLC) structures a project into phases: requirements analysis, system design, implementation, testing, deployment, and maintenance.

Several SDLC models exist, each suited to different project contexts. The Waterfall model is sequential — each phase must finish before the next begins — making it predictable but inflexible to changing requirements. Agile methodologies (Scrum, Kanban) break work into short iterations called sprints, delivering working software incrementally and incorporating feedback continuously. Spiral adds risk management loops to Waterfall, while DevOps extends Agile by integrating continuous integration and continuous delivery (CI/CD) pipelines directly into the development workflow.

The SOLID principles guide object-oriented design toward maintainability: Single Responsibility (a class has one reason to change), Open/Closed (open for extension, closed for modification), Liskov Substitution (subtypes must behave like their base types), Interface Segregation (clients should not depend on methods they don't use), and Dependency Inversion (depend on abstractions, not concretions). Alongside SOLID, design patterns — reusable solutions to recurring design problems — help teams communicate and implement proven architectures quickly.

Testing is non-negotiable in professional software engineering. Unit tests verify individual functions in isolation; integration tests check that modules work together; end-to-end tests simulate real user flows; regression tests ensure new changes don't break existing functionality. Test-Driven Development (TDD) inverts the usual order: write a failing test first, then write the minimum code to pass it, then refactor. This discipline clarifies requirements, reduces bugs, and produces code with near-complete test coverage by construction.

Key terms

SDLC
Software Development Life Cycle — the structured process of planning, designing, building, testing, and maintaining software.
Agile
An iterative development methodology emphasizing short delivery cycles (sprints), cross-functional teams, and continuous stakeholder feedback.
SOLID Principles
Five object-oriented design principles — Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion — promoting maintainable, extensible code.
CI/CD
Continuous Integration / Continuous Delivery — automated pipelines that build, test, and deploy code on every commit, reducing integration risk.
Test-Driven Development (TDD)
A practice where failing tests are written before production code, ensuring every feature is covered by automated tests from the start.
Technical Debt
The accumulated cost of shortcuts and suboptimal decisions in a codebase; it grows over time if not actively paid down through refactoring.

Flashcards

Waterfall Model
A sequential SDLC model where requirements, design, implementation, testing, and deployment each complete fully before the next phase begins.
Scrum
An Agile framework using fixed-length sprints, daily standups, sprint reviews, and retrospectives to deliver software iteratively.
Design Pattern
A reusable solution template for a recurring software design problem; examples include Singleton, Observer, Factory, and Strategy.
Refactoring
Restructuring existing code to improve clarity and reduce complexity without changing its external behavior or functionality.
Code Review
A systematic peer examination of source code to find bugs, enforce standards, and share architectural knowledge before merging.
Coupling
The degree of interdependence between software modules; low coupling makes modules easier to change, test, and reuse independently.
Cohesion
The degree to which elements within a module are related; high cohesion means the module does one thing and does it well.
Dependency Injection
A design technique where dependencies are provided to a component from outside rather than created internally, improving testability.
Microservices
An architectural style that structures an application as a collection of small, independently deployable services communicating over APIs.
Version Control
A system (e.g., Git) that records changes to a codebase over time, enabling collaboration, branching, and rollback of mistakes.
Sprint
A time-boxed iteration (typically 1–4 weeks) in Scrum during which the team commits to completing a defined set of work.
Acceptance Testing
Validation that a system meets business requirements, typically performed by the client or end users before formal sign-off.

Questions

  1. Which SDLC model delivers working software in short iterative cycles and adapts requirements based on stakeholder feedback?

    1. Waterfall
    2. Agile
    3. Spiral
    4. V-Model
    Show answer

    Answer: Agile

    Agile uses iterative sprints to deliver working software incrementally, allowing requirements to evolve based on continuous feedback.

  2. The Single Responsibility Principle states that a class should have exactly one method.

    Show answer

    Answer: False

    SRP means a class should have one reason to change (one responsibility), not one method — a class can have many methods that together serve a single purpose.

  3. In Test-Driven Development, what is the correct order of steps?

    1. Write code → Write test → Refactor
    2. Write test → Write code → Refactor
    3. Refactor → Write test → Write code
    4. Write code → Refactor → Write test
    Show answer

    Answer: Write test → Write code → Refactor

    TDD's red-green-refactor cycle: write a failing test (red), write minimal code to pass it (green), then clean up the code (refactor).

  4. A pipeline that automatically builds and tests code on every commit, reducing integration problems, is called ______ integration.

    Show answer

    Answer: continuous

    Continuous Integration (CI) automatically builds and runs tests whenever code is committed, catching integration issues early.

  5. Which type of test verifies that a recent code change has not broken previously working functionality?

    1. Unit test
    2. Smoke test
    3. Regression test
    4. Load test
    Show answer

    Answer: Regression test

    Regression tests guard against regressions — new changes breaking previously working features — and are re-run after every significant change.

Get a personalized course on Software Engineering built around your child.