Coding Course

Lesson 1 • How Computers Execute Code

Explains the path from source code to machine instructions, covering compilers, interpreters, and runtimes. Grounds all later syntax study in a concrete execution model.

Lesson 2 • Control Flow Essentials

Covers conditional statements and loops that direct program execution. Learners gain the ability to write programs that make decisions and repeat actions.

Lesson 3 • Setting Up Your Development Environment

Guides installation of a code editor, language runtime, and terminal tools. Ensures every learner has an identical, reproducible workspace before writing any code.

Lesson 4 • Reading and Debugging Error Messages

Teaches how to interpret syntax errors, runtime errors, and stack traces. Establishes a systematic debugging mindset from the very first day of coding.

Lesson 1 • Scope and Variable Lifetime

Explains local, global, and block scope and how the runtime resolves variable names. Prevents common bugs caused by unintended variable shadowing or leakage.

Lesson 2 • Defining and Calling Functions

Covers function syntax, parameters, return values, and call mechanics. Establishes functions as the primary tool for encapsulating reusable logic.

Lesson 3 • Organising Code into Modules

Demonstrates how to split code across files using import and export mechanisms. Prepares learners for working in multi-file projects and open-source libraries.

Lesson 1 • Nested Structures and JSON

Handles deeply nested arrays and objects and serialises them to JSON format. Prepares learners to consume and produce the data format used by most web APIs.

Lesson 2 • Arrays and Indexed Collections

Covers array creation, indexing, mutation, and iteration. Arrays are the foundation for nearly every list-processing task in real applications.

Lesson 3 • Transforming and Filtering Collections

Applies map, filter, reduce, and similar methods to process data declaratively. Builds the functional data-pipeline skills used in analytics and UI rendering.

Lesson 4 • Sets and Maps for Unique Data

Introduces Set and Map structures for deduplication and keyed lookups. Expands the learner's toolkit beyond arrays and plain objects.

Lesson 1 • Polymorphism and Interfaces

Demonstrates how different classes can satisfy a common interface and be used interchangeably. Enables flexible, plug-in-style architectures.

Lesson 2 • Encapsulation and Access Control

Covers public, private, and protected members and getter/setter patterns. Teaches learners to hide implementation details and expose clean interfaces.

Lesson 3 • Composition Over Inheritance

Contrasts deep inheritance hierarchies with mixin and composition patterns. Guides learners towards designs that are easier to test and refactor.

Lesson 4 • Classes and Constructors

Introduces class syntax, constructors, and instance creation. Provides the structural foundation for all object-oriented patterns covered in this chapter.

Lesson 1 • Problem Decomposition and Pseudocode

Teaches breaking a problem into sub-problems and expressing solutions in plain language before coding. Reduces errors by separating thinking from syntax.

Lesson 2 • Big-O Complexity Analysis

Introduces time and space complexity notation and teaches how to evaluate algorithm efficiency. Enables informed decisions when performance matters.

Lesson 3 • Searching Algorithms

Covers linear search and binary search with complexity analysis. Learners choose the right search strategy based on data size and sortedness.

Lesson 4 • Recursion and the Call Stack

Explains recursive thinking, base cases, and how the call stack manages recursive calls. Unlocks tree traversal and divide-and-conquer patterns.

Lesson 1 • Callbacks, Promises, and Async/Await

Traces the evolution from callback-based to promise-based to async/await asynchronous code. Learners write clean, non-blocking logic without callback nesting.

Lesson 2 • Error Handling and Resilient Code

Applies structured error handling, custom error types, and fallback strategies to I/O operations. Produces programs that degrade gracefully under failure.

Lesson 3 • Reading and Writing Files

Covers synchronous and asynchronous file I/O, path handling, and error management. Enables programs to persist and retrieve data from the local filesystem.

Lesson 4 • Authentication and Secure API Access

Covers API keys, token-based authentication, and safe credential storage. Prevents common security mistakes when integrating external services.

Lesson 1 • Test-Driven Development Workflow

Applies the red-green-refactor cycle to drive feature implementation through tests. Produces cleaner interfaces because tests define expected behaviour first.

Lesson 2 • Unit Testing Fundamentals

Introduces test structure, assertions, and test runners for verifying individual functions. Builds the habit of writing tests alongside production code.

Lesson 3 • Mocking, Stubs, and Test Isolation

Replaces external dependencies with controlled fakes to isolate the unit under test. Enables fast, deterministic tests that do not require network or database access.

Lesson 4 • Code Quality and Static Analysis

Applies linters, formatters, and type checkers to enforce consistent style and catch bugs statically. Reduces review friction and prevents entire classes of runtime errors.

Lesson 1 • Continuous Integration and Deployment

Automates testing and deployment pipelines so every code push is validated and released safely. Reduces manual steps and human error in the release process.

Lesson 2 • Monitoring and Post-Launch Maintenance

Implements logging, error tracking, and performance monitoring for live applications. Ensures issues are detected and resolved before users are significantly impacted.

Lesson 3 • Project Architecture and Planning

Covers requirements gathering, folder structure design, and technology selection. Prevents costly rework by establishing clear architecture before writing code.

Lesson 4 • Build Tools and Dependency Management

Configures package managers, bundlers, and build scripts to automate repetitive tasks. Produces optimised, production-ready output from development source files.