Computer Programming Course

Lesson 1 • Input, Output, and Basic Formatting

Teaches reading user input and printing formatted output. Connects abstract data concepts to visible, interactive program behavior.

Lesson 2 • Setting Up a Development Environment

Installs and configures a code editor, runtime, and terminal. Ensures every student can write, run, and debug code from day one.

Lesson 3 • Operators and Expressions

Covers arithmetic, relational, logical, and assignment operators. Students can construct and evaluate compound expressions correctly.

Lesson 4 • Variables, Data Types, and Literals

Introduces named storage, primitive types, and literal syntax. Establishes the vocabulary used throughout every subsequent chapter.

Lesson 1 • Comparison and Logical Conditions

Deepens understanding of compound Boolean expressions and short-circuit evaluation. Prevents common logic errors in branching code.

Lesson 2 • Loop Control and Iteration Patterns

Teaches break, continue, and common loop idioms such as accumulator and sentinel patterns. Refines loop design for clarity and correctness.

Lesson 3 • Condition-Controlled Loops

Covers while and do-while loops for repetition driven by a condition. Students handle input validation and event-driven repetition.

Lesson 4 • Count-Controlled Loops

Introduces for loops and range-based iteration for a known number of repetitions. Builds the foundation for all iterative algorithms.

Lesson 1 • Defining and Calling Functions

Covers function declaration, parameter lists, and return values. Establishes the basic unit of code reuse used in every later chapter.

Lesson 2 • Default, Keyword, and Variable Arguments

Introduces flexible parameter signatures including defaults and variadic arguments. Enables functions that adapt to different calling contexts.

Lesson 3 • Scope and Variable Lifetime

Explains local, enclosing, and global scope rules and variable shadowing. Prevents subtle bugs caused by unintended variable sharing.

Lesson 4 • Higher-Order Functions and Lambdas

Covers passing functions as arguments, returning functions, and anonymous lambda syntax. Prepares students for functional programming patterns.

Lesson 1 • Sets and Tuples

Covers unordered unique collections and immutable sequences. Students apply set operations and use tuples for fixed-structure data.

Lesson 2 • Strings as Sequences

Treats strings as indexed character sequences and covers common string operations. Bridges primitive types and collection behavior.

Lesson 3 • Arrays and Lists

Covers indexed sequential storage, element access, and mutation. Provides the most fundamental collection type for ordered data.

Lesson 4 • Choosing and Combining Data Structures

Analyzes time and space trade-offs across collection types. Students design composite structures for realistic data modeling tasks.

Lesson 1 • Inheritance and Method Overriding

Teaches subclass creation, parent-class reuse, and method overriding. Enables hierarchical modeling and code reuse across related types.

Lesson 2 • Composition and Design Principles

Introduces composition over inheritance, single responsibility, and open-closed principles. Students refactor class designs for flexibility.

Lesson 3 • Methods and Encapsulation

Covers instance methods, access modifiers, and data hiding. Students protect internal state and expose clean public interfaces.

Lesson 4 • Polymorphism and Interfaces

Covers duck typing, abstract classes, and interface contracts. Students write code that operates on multiple types through a common interface.

Lesson 1 • Reading and Writing Text Files

Covers opening, reading, writing, and closing files with context managers. Connects in-memory data to persistent storage on disk.

Lesson 2 • Exception Types and the Error Hierarchy

Maps common exception categories and their inheritance hierarchy. Students identify the right exception type for each failure scenario.

Lesson 3 • Try, Except, and Finally Blocks

Covers structured exception handling, multiple except clauses, and cleanup code. Students prevent crashes and release resources reliably.

Lesson 4 • Custom Exceptions and Defensive Programming

Teaches defining custom exception classes and validating inputs proactively. Students design APIs that communicate errors clearly.

Lesson 1 • Algorithm Analysis and Big-O Notation

Introduces time and space complexity and Big-O classification. Gives students a framework for comparing algorithm efficiency objectively.

Lesson 2 • Linear and Binary Search

Implements and compares sequential and binary search algorithms. Students understand the preconditions and performance of each approach.

Lesson 3 • Recursion-Based Problem Solving

Applies recursive thinking to classic problems like binary search trees and permutations. Reinforces recursion from chapter three in algorithmic contexts.

Lesson 4 • Efficient Sorting Algorithms

Implements merge sort and quicksort using divide-and-conquer. Students analyze O(n log n) performance and partition strategies.

Lesson 1 • Code Quality and Refactoring

Covers naming conventions, code smells, and systematic refactoring techniques. Students improve existing code without changing its external behavior.

Lesson 2 • Version Control with Git

Covers repository initialization, commits, branching, and merging. Enables collaborative and solo development with a full change history.

Lesson 3 • Unit Testing and Test-Driven Development

Teaches writing unit tests, assertions, and the red-green-refactor cycle. Students verify correctness and prevent regressions automatically.

Lesson 4 • Documentation and Code Readability

Teaches inline comments, docstrings, and README authoring. Students produce code that teammates can understand and maintain.