Programming Foundations Course

Lesson 1 • How Computers Process Instructions

Covers the relationship between hardware, operating systems, and programs. Establishes the foundation for understanding why code must be precise and structured.

Lesson 2 • Programming Languages Overview

Surveys compiled vs. interpreted languages and high-level vs. low-level distinctions. Helps learners choose appropriate tools for different problem types.

Lesson 3 • Problem-Solving Before Coding

Introduces decomposition, pseudocode, and flowcharts as pre-coding tools. Learners practice translating real problems into structured logical steps.

Lesson 1 • Type Conversion and Casting

Distinguishes implicit coercion from explicit casting and identifies when each occurs. Prevents data-loss bugs that arise from unintended type conversions.

Lesson 2 • Primitive Data Types

Covers integers, floats, booleans, characters, and strings at the language level. Understanding types prevents common runtime errors caused by type mismatches.

Lesson 3 • Arithmetic and Comparison Operators

Teaches arithmetic, comparison, and logical operators with operator precedence rules. Learners build expressions used in every subsequent control-flow construct.

Lesson 4 • Working with Strings

Explores string creation, concatenation, interpolation, and common built-in methods. Strings are the most frequent data type in real-world programs.

Lesson 1 • For Loops and Iteration

Teaches counted iteration with for loops, including loop variables and range expressions. Iteration is the primary mechanism for processing collections and repeating tasks.

Lesson 2 • Conditional Statements

Covers if, else-if, and else constructs for branching program paths. Builds directly on comparison and logical operators from the previous chapter.

Lesson 3 • Switch and Pattern Matching

Introduces multi-branch selection using switch statements and modern pattern matching. Provides cleaner alternatives to long else-if chains for discrete value checks.

Lesson 4 • Loop Control Statements

Explains break, continue, and return within loops to alter iteration flow. Mastery of these statements enables precise control over complex loop logic.

Lesson 1 • Scope and Variable Lifetime

Defines local, enclosing, and global scope and explains variable shadowing. Scope rules determine which data a function can read or modify.

Lesson 2 • Return Values and Output

Teaches how functions produce output through return statements and multiple return values. Learners connect function output to variable assignment and expression evaluation.

Lesson 3 • Parameters and Arguments

Explains positional, default, and keyword arguments and how data flows into functions. Proper parameter design makes functions flexible and reusable across contexts.

Lesson 4 • Recursion Fundamentals

Introduces recursive function design with base cases and recursive cases. Recursion enables elegant solutions to problems with self-similar structure.

Lesson 1 • Multidimensional Arrays

Extends single-dimension arrays to grids and matrices for tabular data. Learners implement row-column traversal patterns used in data and image processing.

Lesson 2 • Dictionaries and Key-Value Stores

Teaches hash-map structures for fast lookup by key rather than position. Key-value stores are essential for configuration, caching, and data modeling.

Lesson 3 • Sets and Unique Collections

Introduces sets for storing unique elements and performing membership tests. Set operations like union and intersection solve deduplication and comparison problems.

Lesson 4 • Arrays and Lists

Covers indexed sequential collections, including creation, access, and mutation. Arrays and lists underpin nearly every data-processing algorithm.

Lesson 1 • Encapsulation and Access Control

Teaches public, protected, and private access levels and getter/setter patterns. Encapsulation protects internal state and defines clear object interfaces.

Lesson 2 • Classes and Objects

Defines classes as blueprints and objects as instances with state and behavior. This section establishes the vocabulary for all subsequent OOP concepts.

Lesson 3 • Polymorphism and Interfaces

Demonstrates how objects of different types respond to the same method call. Polymorphism enables flexible, extensible code that works with future types.

Lesson 4 • Inheritance and Code Reuse

Explains single and multilevel inheritance for sharing behavior across related classes. Inheritance reduces duplication and establishes is-a relationships between types.

Lesson 1 • Debugging Techniques and Tools

Introduces print-based debugging, interactive debuggers, and breakpoint usage. Systematic debugging reduces time spent diagnosing defects in complex programs.

Lesson 2 • Logging and Defensive Programming

Covers logging levels, log formatting, and input validation as preventive measures. Logging and validation reduce the frequency and severity of production failures.

Lesson 3 • Exception Handling Constructs

Covers try, except, finally, and else blocks for structured error management. These constructs prevent crashes and allow programs to recover or report failures cleanly.

Lesson 4 • Raising and Creating Exceptions

Teaches how to raise built-in exceptions and define custom exception classes. Custom exceptions communicate domain-specific error conditions clearly to callers.

Lesson 1 • Using Standard Library Packages

Surveys commonly used standard library modules for math, dates, paths, and utilities. Leveraging built-in packages avoids reinventing well-tested functionality.

Lesson 2 • Structuring a Multi-File Project

Covers directory layout, package initialization, and dependency management basics. A clear project structure enables team collaboration and reliable builds.

Lesson 3 • Reading and Writing Text Files

Covers file open modes, reading methods, and safe file closing with context managers. File I/O is the foundation for data persistence in non-database applications.

Lesson 4 • Working with Structured File Formats

Teaches parsing and writing CSV, JSON, and similar structured formats. Structured formats are the standard interchange medium for data between programs and services.