Computer Software Engineer Course

Lesson 1 • Software Development Lifecycle Models

Covers Waterfall, Iterative, Spiral, and Agile lifecycle models with trade-offs. Enables informed model selection based on project constraints.

Lesson 2 • Software Quality and Reliability Concepts

Introduces quality attributes such as correctness, maintainability, and reliability. Links quality goals to engineering decisions made throughout the lifecycle.

Lesson 3 • Professional Ethics and Responsibilities

Examines ethical obligations, intellectual property, and professional codes of conduct. Grounds technical work in accountability and societal responsibility.

Lesson 1 • Core Programming Concepts

Covers variables, data types, operators, and expressions as the building blocks of any program. Establishes the vocabulary needed for all subsequent coding work.

Lesson 2 • Problem-Solving Strategies

Applies decomposition, pattern recognition, and pseudocode to translate problems into programs. Builds algorithmic thinking as a transferable engineering skill.

Lesson 3 • Functions and Modular Programming

Introduces function definition, parameters, return values, and scope. Promotes code reuse and separation of concerns as foundational design habits.

Lesson 4 • Control Flow and Logic Structures

Teaches conditional statements, loops, and branching to control program execution. Enables construction of programs that respond dynamically to input.

Lesson 1 • Algorithm Design Techniques

Teaches divide-and-conquer, dynamic programming, and greedy strategies. Equips students to design efficient solutions to novel computational problems.

Lesson 2 • Trees and Graph Structures

Covers binary trees, binary search trees (BSTs), heaps, and graph representations. Prepares students for hierarchical and network-based problem domains.

Lesson 3 • Arrays, Strings, and Basic Collections

Examines arrays, strings, and list-based collections as foundational storage mechanisms. Provides the structural vocabulary for more complex data organization.

Lesson 4 • Sorting and Searching Algorithms

Analyzes classic sorting and searching algorithms with time and space complexity. Enables informed algorithm selection based on data size and constraints.

Lesson 1 • Creational and Structural Design Patterns

Covers Singleton, Factory, Builder, Adapter, and Decorator patterns with implementation examples. Provides reusable solutions to recurring structural design problems.

Lesson 2 • UML and Object Modeling

Introduces UML class, sequence, and use-case diagrams for communicating design intent. Bridges requirements and implementation through visual modeling.

Lesson 3 • Behavioral Design Patterns

Examines Observer, Strategy, Command, and Iterator patterns for managing object interaction. Enables flexible, maintainable communication between system components.

Lesson 4 • SOLID Design Principles

Applies the five SOLID principles to evaluate and improve class and module design. Reduces coupling and increases cohesion in object-oriented codebases.

Lesson 1 • Requirements Elicitation Techniques

Covers interviews, workshops, observation, and prototyping as elicitation methods. Connects stakeholder communication directly to accurate requirement capture.

Lesson 2 • Functional and Non-Functional Requirements

Distinguishes functional requirements from quality attributes such as performance and security. Ensures complete specification coverage for both behavior and constraints.

Lesson 3 • System Design and Component Modeling

Applies architectural decisions to component diagrams, software interfaces, and software deployment models. Translates high-level architecture into actionable design artifacts.

Lesson 4 • Software Architecture Styles

Surveys layered, microservices, event-driven, and pipe-and-filter architectural styles. Enables selection of architecture patterns aligned with system quality goals.

Lesson 1 • Test Automation and CI Integration

Builds automated test pipelines using frameworks and continuous integration (CI) tools. Enables fast, repeatable quality feedback throughout the development cycle.

Lesson 2 • Test-Driven Development

Applies the red-green-refactor cycle to drive design through tests. Integrates testing into the development workflow rather than treating it as a separate phase.

Lesson 3 • Testing Fundamentals and Terminology

Defines verification, validation, test levels, and defect taxonomy. Establishes shared vocabulary and conceptual framework for all testing activities.

Lesson 4 • Integration and System Testing

Teaches top-down, bottom-up, and big-bang integration strategies alongside system-level test planning. Validates that assembled components meet end-to-end requirements.

Lesson 1 • Relational Database Fundamentals

Introduces tables, keys, relationships, and the relational model. Provides the conceptual foundation for schema design and SQL-based data management.

Lesson 2 • Database Integration in Applications

Covers ORM frameworks, connection pooling, and query optimisation for application integration. Bridges database design with practical software development workflows.

Lesson 3 • SQL Querying and Data Manipulation

Teaches SELECT, JOIN, aggregation, subqueries, and DML statements. Enables retrieval and manipulation of data across complex relational schemas.

Lesson 4 • NoSQL Databases and Use Cases

Surveys document, key-value, column-family, and graph NoSQL models with trade-offs. Enables selection of the appropriate data store for varied application requirements.

Lesson 1 • Continuous Integration and Delivery

Builds CI/CD pipelines that automate build, test, and software deployment stages. Reduces release risk and accelerates feedback loops in professional development environments.

Lesson 2 • Agile Frameworks: Scrum and Kanban

Teaches Scrum ceremonies, roles, and artifacts alongside Kanban flow management. Provides practical frameworks for iterative, team-based software delivery.

Lesson 3 • Team Dynamics and Stakeholder Management

Addresses communication, conflict resolution, and stakeholder reporting in engineering teams. Develops the interpersonal skills needed to sustain productive, high-performing teams.

Lesson 4 • Version Control and Collaboration Workflows

Applies branching strategies, pull requests, and code review processes to team development. Ensures consistent, traceable collaboration across distributed engineering teams.