Learn to Program Course

Lesson 1 • Setting Up a Development Environment

Guides installation of a code editor, runtime, and terminal tools. A working environment is the prerequisite for every hands-on exercise ahead.

Lesson 2 • Choosing Your First Programming Language

Compares beginner-friendly languages by syntax clarity, community support, and job relevance. Students select a language and justify the choice.

Lesson 3 • Reading and Writing Basic Syntax

Introduces statements, expressions, comments, and whitespace rules. Students write and execute simple programs to internalize syntax conventions.

Lesson 1 • Primitive Data Types

Examines integers, floats, booleans, and strings as the building blocks of all data. Students practice type-specific operations and identify type mismatches.

Lesson 2 • Comparison and Logical Operators

Introduces relational and logical operators that produce boolean results. These operators power every conditional and loop construct in later chapters.

Lesson 3 • Type Conversion and Casting

Explains implicit coercion and explicit casting between data types. Students debug type errors and write safe conversion routines.

Lesson 4 • Arithmetic and Assignment Operators

Teaches the full set of arithmetic operators and compound assignment shortcuts. Students compute results and update variable values in short programs.

Lesson 1 • Switch and Match Constructs

Presents multi-branch selection as a cleaner alternative to long if-else chains. Students refactor conditional code into switch or match blocks.

Lesson 2 • If, Else If, and Else Statements

Builds decision trees using conditional blocks and nested conditions. Students trace execution paths and avoid common logic errors.

Lesson 3 • While and Do-While Loops

Introduces condition-controlled repetition for unknown iteration counts. Students write loops that read input until a valid value is entered.

Lesson 4 • Break, Continue, and Loop Control

Teaches early exit and skip mechanisms that fine-tune loop behavior. Students refactor loops to eliminate unnecessary iterations.

Lesson 1 • Scope and Variable Lifetime

Defines local, enclosing, and global scope and explains variable shadowing. Students trace variable values across nested function calls.

Lesson 2 • Defining and Calling Functions

Covers function declaration syntax, naming, and invocation. Students convert repeated code blocks into named functions immediately.

Lesson 3 • Recursion Fundamentals

Introduces self-calling functions with base cases and recursive steps. Students implement classic recursive algorithms and analyze call stack depth.

Lesson 4 • Parameters, Arguments, and Defaults

Explains positional parameters, default values, and argument passing modes. Students write flexible functions that handle optional inputs gracefully.

Lesson 1 • Dictionaries and Key-Value Stores

Introduces hash-map structures for fast key-based lookup. Students model real-world entities as dictionaries and perform CRUD operations.

Lesson 2 • Iterating Over Collections

Applies for-each loops and iterators to process every element in a collection. Students combine iteration with conditionals to filter and transform data.

Lesson 3 • Lists and Arrays Fundamentals

Covers ordered, indexed collections and their memory layout. Students create, access, and modify lists using index notation.

Lesson 4 • Sets and Tuples

Contrasts unordered unique sets with immutable tuples and their use cases. Students apply set operations to solve membership and deduplication problems.

Lesson 1 • Inheritance and Code Reuse

Extends base classes to create specialized subclasses without duplicating code. Students build a three-level class hierarchy and override methods.

Lesson 2 • Composition Over Inheritance

Contrasts inheritance hierarchies with object composition for flexible design. Students refactor an inheritance-heavy design into composable components.

Lesson 3 • Encapsulation and Access Control

Teaches hiding internal state behind public interfaces using access modifiers. Students refactor classes to expose only necessary data.

Lesson 4 • Classes and Objects

Defines classes as blueprints and objects as instances with state and behavior. Students write classes with attributes and methods for a simple domain.

Lesson 1 • Exception Handling Fundamentals

Teaches try-except-finally blocks to intercept and recover from runtime errors. Students wrap risky operations and provide meaningful error messages.

Lesson 2 • Reading and Writing Files

Covers opening, reading, writing, and closing files using context managers. Students parse a text file and write processed results to a new file.

Lesson 3 • Custom Exceptions and Error Design

Guides creation of domain-specific exception classes for clearer error communication. Students design an exception hierarchy for a small application.

Lesson 4 • Structured Data Formats

Introduces CSV and JSON as common interchange formats for program data. Students serialize and deserialize data between in-memory objects and files.

Lesson 1 • Deployment and Running in Production

Covers environment variables, basic server deployment, and monitoring fundamentals. Students deploy the project to a cloud platform and verify it runs correctly.

Lesson 2 • Writing Automated Tests

Introduces unit testing frameworks and test-driven development principles. Students write tests before implementing each module function.

Lesson 3 • Version Control with Git

Covers commits, branches, merges, and pull requests as a professional workflow. Students manage the project repository from init to final merge.

Lesson 4 • Packaging and Dependency Management

Teaches virtual environments, package managers, and project configuration files. Students isolate dependencies and produce a reproducible build.