Software Engineering Course

Lesson 1 • Professional and Ethical Responsibilities

Examines codes of conduct, intellectual property, and ethical decision-making in software work. Connects professional standards to real engineering choices.

Lesson 2 • Core Engineering Principles

Introduces abstraction, modularity, separation of concerns, and encapsulation. These principles underpin every design and architecture decision covered later.

Lesson 3 • Software Quality Attributes

Covers reliability, maintainability, system scalability, and usability as measurable goals. Students learn to evaluate trade-offs among competing quality attributes.

Lesson 4 • What Is Software Engineering

Defines software engineering and distinguishes it from programming. Anchors the chapter by framing engineering rigor as essential to professional practice.

Lesson 1 • Waterfall and Sequential Models

Analyzes the waterfall model's phase-gate structure and its strengths in stable-requirement projects. Identifies limitations that motivated iterative alternatives.

Lesson 2 • Selecting the Right Model

Provides a decision framework based on project size, risk, and requirement stability. Students practice model selection through scenario analysis.

Lesson 3 • Iterative and Incremental Models

Covers spiral, incremental, and unified process models that deliver software in cycles. Students compare risk management strategies across these models.

Lesson 4 • Overview of SDLC Phases

Maps the standard phases from requirements through maintenance. Establishes a shared framework for all subsequent methodology comparisons.

Lesson 1 • Use Cases and User Stories

Introduces use case diagrams and narrative user stories as complementary specification tools. Students model system behaviour from an actor-centric perspective.

Lesson 2 • Functional and Non-Functional Requirements

Distinguishes behavioural requirements from quality constraints and system properties. Students write testable statements for both categories.

Lesson 3 • Requirements Validation and Management

Covers review techniques, prototyping validation, and change management processes. Students learn to handle evolving requirements without scope creep.

Lesson 4 • Requirements Specification Documents

Guides students in structuring formal specification documents with traceability matrices. Connects specification quality to downstream design and testing accuracy.

Lesson 1 • Structural and Behavioural Patterns

Introduces Adapter, Decorator, Observer, Strategy, and Command patterns. Students compose patterns to solve multi-concern design problems.

Lesson 2 • SOLID Design Principles

Teaches the five SOLID principles as guidelines for flexible, extensible code. Students refactor poorly designed examples to satisfy each principle.

Lesson 3 • Creational Design Patterns

Covers Singleton, Factory, Abstract Factory, Builder, and Prototype patterns. Students implement each pattern and identify appropriate use contexts.

Lesson 4 • Structured and Object-Oriented Design

Contrasts procedural decomposition with object-oriented design strategies. Students model systems using classes, responsibilities, and collaborations.

Lesson 1 • Architectural Evaluation and Trade-offs

Applies structured evaluation methods to compare candidate architectures against quality attributes. Students conduct a scenario-based architecture review.

Lesson 2 • Architectural Thinking and Views

Introduces the concept of architectural views and stakeholder-driven documentation. Students distinguish logical, process, physical, and development views.

Lesson 3 • Event-Driven and Reactive Architectures

Introduces message brokers, event sourcing, and CQRS as patterns for asynchronous systems. Students model event flows for high-throughput scenarios.

Lesson 4 • Layered and Client-Server Architectures

Analyzes layered architecture and client-server patterns as foundational styles. Students evaluate their suitability for enterprise and web applications.

Lesson 1 • Refactoring Techniques

Introduces systematic refactoring moves such as extract method, rename, and replace conditional. Students apply code refactoring safely using automated test coverage.

Lesson 2 • Coding Standards and Conventions

Establishes naming, formatting, and commenting conventions as team-level agreements. Students audit existing code against a defined standard and produce corrections.

Lesson 3 • Clean Code Principles

Covers meaningful names, small functions, and minimal side effects as clean code tenets. Students rewrite complex functions to satisfy readability criteria.

Lesson 4 • Technical Debt Management

Defines technical debt, its causes, and strategies for controlled repayment. Students assess a codebase, quantify debt, and propose a remediation plan.

Lesson 1 • Test Automation and Continuous Testing

Introduces automation frameworks, test pyramid strategy, and CI pipeline integration. Students configure an automated test suite that runs on every code commit.

Lesson 2 • Black-Box and White-Box Techniques

Teaches equivalence partitioning, boundary analysis, and path coverage as complementary techniques. Students derive test cases from both specification and code structure.

Lesson 3 • System and Acceptance Testing

Covers end-to-end system testing, regression suites, and user acceptance testing processes. Students design a system test plan aligned with requirements.

Lesson 4 • Unit and Integration Testing

Covers test-driven development, mock objects, and integration test strategies. Students write unit tests and integration tests for a provided module set.

Lesson 1 • Project Planning and Scope Management

Covers work breakdown structures, milestone definition, and scope baseline creation. Students decompose a project into manageable tasks with clear deliverables.

Lesson 2 • Release Planning and Delivery Metrics

Introduces release train planning, velocity tracking, and delivery health metrics. Students interpret burndown charts and adjust plans based on real data.

Lesson 3 • Effort Estimation Techniques

Introduces function point analysis, story points, and expert judgment as estimation methods. Students calibrate estimates using historical velocity data.

Lesson 4 • Risk Management in Software Projects

Teaches risk identification, probability-impact assessment, and mitigation strategy selection. Students build a risk register and response plan for a sample project.