Programming Foundations: Fundamentals Course

Lesson 1 • Problem-Solving Before Coding

Introduces decomposition, pseudocode, and flowcharts as pre-coding tools. Trains systematic thinking that reduces errors in later chapters.

Lesson 2 • Setting Up a Development Environment

Guides installation of a code editor, runtime, and terminal. Establishes a working workspace used throughout the entire course.

Lesson 3 • How Computers Execute Instructions

Covers the fetch-decode-execute cycle and the role of hardware in running programs. Grounds all later coding concepts in physical machine behavior.

Lesson 1 • Arithmetic and Assignment Operators

Teaches addition, subtraction, modulo, and compound assignment operators. Enables learners to perform calculations central to all programming tasks.

Lesson 2 • Type Conversion and Casting

Explains implicit coercion and explicit casting between data types. Prevents common bugs caused by unexpected type mismatches.

Lesson 3 • Variables and Memory Storage

Explains how variables name memory locations and hold values. Connects abstract data storage to concrete program behavior.

Lesson 4 • Comparison and Logical Operators

Introduces relational operators and Boolean logic for decision-making. Directly supports the conditional statements taught in the next chapter.

Lesson 1 • If-Else Conditional Statements

Covers single-branch, two-branch, and multi-branch if-else structures. Forms the primary decision-making tool used in every subsequent chapter.

Lesson 2 • Truthy and Falsy Value Evaluation

Examines how non-Boolean values are evaluated in conditional contexts. Prevents subtle logic bugs common in dynamically typed languages.

Lesson 3 • Switch and Match Statements

Introduces multi-case branching as a cleaner alternative to long else-if chains. Improves code readability when handling discrete value sets.

Lesson 1 • While and Do-While Loops

Introduces condition-driven loops that repeat until a Boolean expression is false. Establishes the concept of loop guards and termination conditions.

Lesson 2 • For Loops and Counting Patterns

Covers counter-based iteration with initialization, condition, and increment. Enables precise control over iteration count for predictable tasks.

Lesson 3 • Iterating Over Collections

Applies for-each and index-based loops to arrays and lists. Bridges loop fundamentals to the data structures introduced in the next chapter.

Lesson 4 • Loop Control with Break and Continue

Teaches early exit and iteration skipping to refine loop behavior. Gives learners fine-grained control over complex repetition scenarios.

Lesson 1 • Scope and Variable Lifetime

Distinguishes local, enclosing, and global scope and their effect on variable access. Prevents naming conflicts and unintended side effects in larger programs.

Lesson 2 • Return Values and Output

Teaches how functions produce output through return statements. Connects function output to variable assignment and expression evaluation.

Lesson 3 • Recursion Fundamentals

Introduces self-calling functions with base cases and recursive steps. Prepares learners for tree traversal and divide-and-conquer algorithms later.

Lesson 4 • Parameters and Arguments

Explains how data is passed into functions via parameters and arguments. Enables functions to operate on varying inputs without code duplication.

Lesson 1 • Dictionaries and Key-Value Pairs

Teaches hash-map-style structures that associate keys with values. Enables fast lookups and structured data representation in programs.

Lesson 2 • Common Collection Operations

Applies sorting, searching, filtering, and mapping to collections. Consolidates all collection types into practical, reusable programming patterns.

Lesson 3 • Dynamic Lists and Resizing

Introduces resizable list structures that grow and shrink at runtime. Enables flexible data storage without predefined size constraints.

Lesson 4 • Sets and Uniqueness Constraints

Explains sets as unordered collections that enforce element uniqueness. Useful for deduplication and membership testing in real programs.

Lesson 1 • Methods and Behavior

Covers instance methods, static methods, and the self/this reference. Enables objects to encapsulate both data and the operations that act on it.

Lesson 2 • Inheritance and Code Reuse

Explains parent-child class relationships and method inheritance. Reduces duplication by sharing behavior across related class hierarchies.

Lesson 3 • Classes and Object Instantiation

Defines classes as blueprints and objects as runtime instances. Introduces the primary abstraction mechanism for organizing complex programs.

Lesson 4 • Polymorphism and Interfaces

Introduces runtime method dispatch and interface contracts for flexible design. Enables writing code that works with any object conforming to a shared interface.

Lesson 1 • Debugging Tools and Techniques

Teaches breakpoints, watch expressions, and step-through execution in a debugger. Accelerates root-cause identification for complex bugs.

Lesson 2 • Writing and Running Unit Tests

Introduces test functions, assertions, and test runners for automated verification. Ensures individual functions behave correctly before integration.

Lesson 3 • Types of Errors in Programs

Distinguishes syntax, runtime, and logic errors by cause and detection method. Builds diagnostic vocabulary used throughout all debugging activities.

Lesson 4 • Exception Handling Mechanisms

Covers try-catch-finally blocks and custom exception types for controlled error recovery. Prevents program crashes and enables meaningful user-facing error messages.