Computer Coding Course

Lesson 1 • Logic and Algorithmic Thinking

Introduces step-by-step problem decomposition and flowchart notation. Students practice translating real tasks into ordered logical steps.

Lesson 2 • Setting Up a Coding Environment

Guides installation of a code editor, runtime, and version control tool. A working local environment is required for all hands-on exercises ahead.

Lesson 3 • What Computers Do with Code

Explains how hardware executes software instructions step by step. Grounds all later syntax study in a concrete mental model of computation.

Lesson 1 • Declaring and Assigning Variables

Covers naming rules, scope basics, and assignment syntax. Proper variable declaration prevents the most common beginner bugs.

Lesson 2 • Boolean Logic and Comparisons

Teaches true/false values, comparison operators, and logical connectives. Boolean mastery is the foundation of all conditional and loop logic.

Lesson 3 • Working with Numbers and Strings

Explores integer, float, and string types with their built-in operations. Students manipulate text and perform arithmetic in short exercises.

Lesson 1 • Loop Control and Nested Loops

Covers break, continue, and nested loop patterns for complex iteration. Students solve grid and search problems requiring multi-level loops.

Lesson 2 • Switch and Pattern Matching

Introduces multi-case selection structures as an alternative to long else-if chains. Students choose the right structure for readability and performance.

Lesson 3 • If-Else Conditional Statements

Covers single-branch, two-branch, and multi-branch conditional syntax. Conditionals let programs respond differently to different inputs.

Lesson 4 • Combining Conditions and Loops

Integrates conditionals inside loops to filter and transform data. Students build small programs that validate input and process lists.

Lesson 1 • Recursion Fundamentals

Introduces self-calling functions, base cases, and call-stack behavior. Recursion solves problems that naturally decompose into smaller versions of themselves.

Lesson 2 • Higher-Order Functions

Covers passing functions as arguments and returning functions as values. Higher-order functions enable powerful, concise data-transformation pipelines.

Lesson 3 • Defining and Calling Functions

Covers function declaration syntax, parameters, and return values. Functions eliminate repetition and make code easier to maintain.

Lesson 4 • Scope and Variable Lifetime

Explains local, enclosing, and global scope rules and their practical impact. Scope mastery prevents accidental variable collisions in larger programs.

Lesson 1 • Dictionaries and Key-Value Stores

Introduces hash-map structures for fast lookup by named key. Dictionaries model real-world records and configuration data naturally.

Lesson 2 • Arrays and Lists

Covers ordered, index-based collections and their core operations. Arrays are the most fundamental multi-value structure in programming.

Lesson 3 • Choosing the Right Data Structure

Compares time and space trade-offs across all covered structures. Students analyze problem requirements and justify their structural choices.

Lesson 4 • Sets and Tuples

Covers unordered unique collections and immutable ordered sequences. Students choose sets for membership tests and tuples for fixed records.

Lesson 1 • Classes and Objects

Defines classes as blueprints and objects as instances with attributes. Students create classes that bundle related data and behavior together.

Lesson 2 • Methods and Encapsulation

Covers instance methods, access modifiers, and data hiding principles. Encapsulation protects internal state and exposes clean public interfaces.

Lesson 3 • Object-Oriented Design Principles

Introduces SOLID principles and common design patterns at a conceptual level. Students refactor procedural code into well-structured class designs.

Lesson 4 • Polymorphism and Interfaces

Explores method overriding, duck typing, and interface contracts. Polymorphism lets one interface work across many object types.

Lesson 1 • Reading and Writing Files

Covers opening, reading, writing, and closing text and binary files. File I/O connects programs to persistent data stored on disk.

Lesson 2 • Writing Defensive Code

Teaches input validation, assertions, and guard clauses to prevent errors early. Defensive patterns make programs resilient to unexpected inputs.

Lesson 3 • Debugging Strategies and Tools

Covers print debugging, breakpoints, and step-through execution in a debugger. Systematic debugging skills reduce time spent fixing errors.

Lesson 4 • Working with Structured File Formats

Teaches parsing and generating CSV and JSON data files. Structured formats are the standard for data exchange between systems.

Lesson 1 • Capstone Project Build and Review

Students implement, test, and present their capstone projects for peer review. The review process reinforces code quality and communication skills.

Lesson 2 • Big-O Complexity Analysis

Introduces O(1), O(n), O(log n), and O(n²) complexity classes with examples. Students evaluate code efficiency and identify bottlenecks.

Lesson 3 • Capstone Project Planning

Guides requirements gathering, design, and task breakdown for a full project. Planning skills ensure students deliver complete, working software.

Lesson 4 • Sorting Algorithms

Teaches bubble, selection, insertion, and merge sort with trade-off analysis. Sorting is a gateway to understanding divide-and-conquer strategies.