Software Programming Course

Lesson 1 • Choosing and Installing a Language

Compares programming language paradigms and guides installation of a beginner-friendly language runtime. Sets a consistent toolchain for the entire course.

Lesson 2 • How Computers Execute Programs

Explains the fetch-decode-execute cycle, memory, and the role of the operating system. Grounds all later coding concepts in hardware reality.

Lesson 3 • Version Control with Git Basics

Introduces Git as a safety net for code changes and collaboration. Students commit their first project, establishing habits used in every later chapter.

Lesson 1 • Working with Strings

Explores string indexing, slicing, concatenation, and common built-in methods. String manipulation is essential for user input and output in later projects.

Lesson 2 • Variables and Assignment

Covers variable declaration, naming conventions, and memory binding. Understanding variables is prerequisite to every subsequent coding concept.

Lesson 3 • Operators and Expressions

Teaches arithmetic, comparison, logical, and assignment operators with precedence rules. Expressions are the building blocks of all control flow covered next.

Lesson 4 • Primitive Data Types

Examines integers, floats, booleans, and strings with their memory implications. Correct type selection prevents common bugs introduced later in logic chapters.

Lesson 1 • Conditional Statements

Covers if, else-if, and else branches with Boolean conditions. Conditionals are the primary mechanism for decision-driven logic in all programs.

Lesson 2 • Debugging Control Flow Logic

Uses print statements and a debugger to trace conditional and loop execution. Systematic debugging skills reduce time spent fixing logic errors in later projects.

Lesson 3 • Loops and Iteration

Introduces while and for loops for repeating operations over data or counts. Iteration underpins collections, algorithms, and data processing covered later.

Lesson 4 • Loop Control Statements

Explains break, continue, and return within loops to alter iteration flow. Precise loop control is critical for writing efficient, correct algorithms.

Lesson 1 • Organizing Code into Modules

Shows how to split code across files and import functionality between modules. Modular design is the foundation of the larger projects in advanced chapters.

Lesson 2 • Defining and Calling Functions

Covers function syntax, parameters, return values, and call mechanics. Functions are the primary unit of code reuse throughout the rest of the course.

Lesson 3 • Recursion Fundamentals

Introduces recursive thinking with base cases and recursive cases. Recursion is foundational for tree traversal and divide-and-conquer algorithms introduced later.

Lesson 4 • Default and Keyword Arguments

Demonstrates optional parameters, default values, and named argument passing. Flexible function signatures make APIs easier to use and extend.

Lesson 1 • Choosing the Right Data Structure

Compares time and space complexity of lists, dicts, and sets for common operations. Informed structure selection is critical for the algorithm chapter ahead.

Lesson 2 • Sets and Uniqueness Operations

Introduces sets for deduplication, membership testing, and set algebra. Set operations provide efficient solutions to problems involving unique elements.

Lesson 3 • Tuples and Immutable Sequences

Explains tuples, their immutability, and use cases such as multiple return values. Choosing tuples over lists signals intent and prevents accidental mutation.

Lesson 4 • Lists and Dynamic Arrays

Covers list creation, indexing, slicing, and mutation methods. Lists are the most common collection type and appear in every subsequent project.

Lesson 1 • Classes and Object Instances

Defines class syntax, constructors, and instance creation. Classes are the primary abstraction mechanism for all object-oriented design patterns ahead.

Lesson 2 • Object-Oriented Design Principles

Introduces SOLID principles and common design patterns at a conceptual level. These principles guide the architecture decisions made in the final project chapter.

Lesson 3 • Polymorphism and Duck Typing

Explains how objects of different classes share a common interface through polymorphism. Polymorphic design makes systems flexible and easier to extend.

Lesson 4 • Inheritance and Code Reuse

Demonstrates single and multi-level inheritance with method overriding. Inheritance enables hierarchical modeling and reduces code duplication across related classes.

Lesson 1 • Logging and Observability

Introduces structured logging as a replacement for print-based debugging. Logs provide runtime visibility essential for diagnosing issues in deployed applications.

Lesson 2 • Understanding Exceptions and Errors

Distinguishes syntax errors, runtime exceptions, and logical errors by category. Correct classification speeds diagnosis and informs the right handling strategy.

Lesson 3 • Input Validation and Defensive Coding

Applies validation patterns to guard functions against bad input before processing. Defensive coding reduces the surface area for runtime failures in production.

Lesson 4 • Raising and Creating Custom Exceptions

Shows how to raise exceptions intentionally and define domain-specific exception classes. Custom exceptions make library and API error contracts explicit.

Lesson 1 • Project Planning and Requirements

Translates a problem statement into user stories, acceptance criteria, and a module plan. Clear requirements prevent scope creep and guide all implementation decisions.

Lesson 2 • Documentation and Code Comments

Teaches docstring conventions, inline comments, and generating API reference docs. Good documentation makes code usable by teammates and future maintainers.

Lesson 3 • Packaging and Sharing Your Project

Guides dependency management, project packaging, and publishing to a package registry. Distributable packages are the standard deliverable in professional software teams.

Lesson 4 • Automated Testing with Unit Tests

Covers test case design, assertions, and running a test suite with a standard framework. Automated tests catch regressions and validate behaviour as the project grows.