Software Programmer Course

Lesson 1 • Setting Up Your Development Environment

Installs and configures a code editor, runtime, and package manager. Ensures every student has an identical, reproducible workspace before writing any code.

Lesson 2 • Command-Line Proficiency

Teaches navigation, file manipulation, and process management in a terminal. Command-line fluency accelerates every subsequent workflow in the course.

Lesson 3 • Version Control with Git

Introduces Git as the industry-standard tool for tracking changes and collaborating. Students commit, branch, and push code by the end of this section.

Lesson 1 • Collections and Iteration Patterns

Introduces arrays, lists, and dictionaries for storing grouped data. Students apply iteration patterns to process real datasets efficiently.

Lesson 2 • Variables, Types, and Operators

Explains how data is stored, typed, and transformed through expressions. Provides the vocabulary needed to read and write any code statement.

Lesson 3 • Functions and Modular Code

Defines functions as reusable, testable units of logic. Modular design reduces duplication and is the foundation of all larger programs in this course.

Lesson 4 • Control Flow and Decision Making

Covers conditionals and loops that direct program execution paths. Students implement branching logic and iterative algorithms from scratch.

Lesson 1 • Composition and Dependency Injection

Contrasts composition with inheritance and introduces dependency injection. Students learn when to prefer has-a relationships over is-a hierarchies.

Lesson 2 • Classes and Objects

Defines classes as blueprints and objects as instances with state and behavior. Connects OOP syntax to the modular functions introduced in the previous chapter.

Lesson 3 • Inheritance and Polymorphism

Models is-a relationships through class hierarchies and method overriding. Students write polymorphic code that handles multiple types through a single interface.

Lesson 4 • SOLID Design Principles

Applies five foundational OOP design principles to real code examples. Students refactor poorly structured classes into clean, maintainable designs.

Lesson 1 • Sorting and Searching Algorithms

Implements and compares classic sorting and searching algorithms. Students benchmark implementations and justify algorithm selection by complexity.

Lesson 2 • Linear Data Structures

Covers arrays, linked lists, stacks, and queues with their trade-offs. Students implement each structure and identify appropriate use cases.

Lesson 3 • Complexity Analysis

Introduces Big-O notation for measuring algorithm efficiency. Students evaluate code performance before choosing between competing implementations.

Lesson 4 • Algorithm Design Strategies

Introduces divide-and-conquer, dynamic programming, and greedy approaches. Students decompose complex problems into solvable subproblems.

Lesson 1 • Relational Database Fundamentals

Explains tables, keys, and relationships as the foundation of relational databases. Students model a domain using entity-relationship diagrams before writing any SQL.

Lesson 2 • Database Integration in Application Code

Connects an application to a database using an ORM and raw query patterns. Students build a repository layer that abstracts persistence from business logic.

Lesson 3 • NoSQL and Document Stores

Contrasts document, key-value, and column-family stores with relational databases. Students choose the right persistence model for a given data shape.

Lesson 4 • SQL Query Language

Covers SELECT, INSERT, UPDATE, DELETE, and JOIN operations. Students write queries that answer real business questions against a sample dataset.

Lesson 1 • Building a RESTful API

Designs and implements REST endpoints following resource-oriented conventions. Students create a CRUD API backed by the database layer from the previous chapter.

Lesson 2 • Authentication and Authorization

Implements token-based authentication and role-based access control. Students secure endpoints so only authorised users can access protected resources.

Lesson 3 • Consuming External APIs

Makes authenticated HTTP requests to third-party services and handles responses. Students integrate a public API into their application using best practices.

Lesson 4 • HTTP and the Web Request Cycle

Explains HTTP methods, status codes, headers, and the request-response model. This mental model underpins every API and web framework used later.

Lesson 1 • Integration and API Testing

Tests interactions between components and validates API contracts end-to-end. Students catch integration bugs that unit tests cannot detect.

Lesson 2 • Unit Testing in Practice

Writes isolated unit tests for functions and classes using a testing framework. Students achieve high coverage on core business logic modules.

Lesson 3 • Test-Driven Development

Applies the red-green-refactor cycle to drive design through failing tests. Students experience how TDD produces simpler, more testable code.

Lesson 4 • Testing Fundamentals and Strategy

Introduces the testing pyramid and the cost-benefit trade-offs of each layer. Students plan a test strategy before writing a single test case.

Lesson 1 • Resilience and Fault Tolerance

Designs systems that degrade gracefully under failure using circuit breakers and retries. Students apply resilience patterns to the API built in earlier chapters.

Lesson 2 • Scalability and Performance Design

Covers horizontal scaling, caching strategies, and load balancing at the design stage. Students identify bottlenecks before writing code using capacity planning.

Lesson 3 • Architectural Patterns Overview

Surveys layered, event-driven, and microservices architectures with their trade-offs. Students map a requirements document to an appropriate architectural style.

Lesson 4 • System Design Practice

Applies all architectural concepts to design a realistic distributed system end-to-end. Students present and defend their designs against scalability and failure scenarios.