Programming FoundationsPublished

Course 02

Programming Foundations: From Algorithms to JavaScript

Learn to translate clear business rules into readable, robust JavaScript programs. Practice critical thinking, data modeling, debugging and testing through small everyday situations, then build two complete projects.

Beginner35 to 45 hours including practice53 lessonsUpdated October 2026

Start learning

Learning outcomes

Question assumptions and define expected behavior before coding
Translate algorithms into variables, conditions, loops and functions
Model and transform arrays, objects and text without unintended mutation
Validate input, distinguish missing data and handle failure explicitly
Debug by reproducing a mismatch and testing a specific hypothesis
Use promises and async/await with clear success and failure paths
Organize a program into modules with focused responsibilities
Write meaningful tests, including boundaries and invalid input
Refactor while preserving behavior and explain business tradeoffs
Build and review complete student-report and order-management programs

Prerequisites

Software Foundations: From Needs to Programs
A desktop browser with developer tools and a text editor
Node.js LTS for file-based modules and projects (introduced in Module 13)
No previous JavaScript knowledge required

Curriculum

A guided path, lesson by lesson

18 modules · 53 lessons

Module 1

From Algorithm to Program

Three complete lessons: understand execution, translate a clear rule and check the result. Use a reasoning notebook and the browser console; no web interface is required.

What Happens When We Run Code?

Understand execution, predict output and distinguish instructions from intentions.

40 min 2

Translate Clear Steps into JavaScript

Name the information, explain each calculation and adapt a rule without guessing.

45 min 3

Compare Expected and Actual Results

Investigate mismatches, challenge a working example and revise the program when a rule changes.

50 min

Module 2

Variables, Data and Memory

Choose representations and translate a confirmed pricing policy.

Variables and Constants

Distinguish a stable input from changing program state

25 min 2

Primitive Data Types

Choose data types according to meaning

30 min 3

Operators, Expressions and the Price Calculator

Translate an agreed order of calculations into expressions

45 min

Module 3

Making Decisions

Turn explicit business rules into readable Boolean decisions.

Boolean Logic

Combine clear yes/no statements into business decisions

25 min 2

Conditions and Readable Branches

Select behavior with if, else if and else

30 min 3

Translate Business Rules into Code

Separate eligibility from calculation

40 min

Module 4

Repetition and Loops

Trace repeated work, stopping conditions and small statistics.

Why We Need Loops

Recognize repeated work and define an accumulator

20 min 2

The for Loop

Trace initialization, condition and update

25 min 3

The while Loop

Use condition-based repetition

25 min 4

Loop Control and Small Statistics

Use break and continue deliberately

30 min

Module 5

Functions and Program Decomposition

Give responsibilities clear inputs, outputs and boundaries.

Why Functions?

Extract a clear responsibility into a function

30 min 2

Parameters, Arguments and Return Values

Make a function contract explicit

30 min 3

Scope and Local Reasoning

Explain block, function and global scope

30 min 4

Function Expressions, Arrow Functions and Callbacks

Treat a function as a value

40 min

Module 6

Arrays

Represent, update, traverse and transform ordered collections.

Representing Collections with Arrays

Model an ordered collection

25 min 2

Updating Arrays and Understanding References

Distinguish reassignment from mutation

35 min 3

Iterating over Arrays and Computing Statistics

Choose index-based or value-based iteration

40 min 4

Transforming and Querying Arrays

Choose a collection method by the question being asked

45 min

Module 7

Objects and Structured Data

Model entities, control mutation and build a first student report.

Why Objects?

Group related information into an entity

25 min 2

Reading, Updating and Copying Objects

Choose dot or bracket access

35 min 3

Arrays of Objects and a Product Report

Combine collection methods with structured records

45 min 4

Nested Data and the Student Report Lab

Access optional nested data without hiding missing information

45 min

Module 8

Strings and Data Cleaning

Normalize deliberately without inventing or destroying information.

Working with Strings

Apply string operations according to a stated purpose

25 min 2

Data Cleaning without Inventing Data

Separate normalization from validation

35 min

Module 9

Errors and Debugging

Reproduce failures, read evidence and test one hypothesis at a time.

Types of Errors

Distinguish syntax, runtime and logic errors

25 min 2

Reading Error Messages

Extract actionable information from an error

25 min 3

A Systematic Debugging Method

Test one hypothesis at a time

35 min 4

Browser Developer Tools for Reasoning

Inspect execution with breakpoints and stepping

30 min

Module 10

Defensive Programming

Make input contracts, exceptions and missing states explicit.

Input Validation and Guard Clauses

Turn preconditions into explicit checks

35 min 2

Exceptions and try / catch

Distinguish returned validation results from exceptions

30 min 3

Edge Cases and Explicit Absence

Separate normal, boundary and invalid cases

35 min

Module 11

Understanding JavaScript Execution

Trace values, calls and synchronous work before studying waiting.

Execution Order and Visible State

Trace statements and calls in order

25 min 2

The Call Stack

Trace nested function calls and returns

25 min 3

Synchronous Work and Waiting

Distinguish sequential work from an operation that completes later

25 min

Module 12

Introduction to Asynchronous JavaScript

Use local simulations to learn promises, await and failure handling.

Why Asynchronous Programming Exists

Represent a result that is not available yet

25 min 2

Promises: A Contract for Later Completion

Explain pending, fulfilled and rejected states

35 min 3

async / await and Readable Dependencies

Await a result inside an async function

35 min 4

Asynchronous Errors and Honest Failure States

Catch awaited rejection at a useful boundary

35 min

Module 13

Modules and Code Organization

Move to a small file-based program with explicit dependencies.

Why Split Code into Modules?

Organize a program by responsibility

30 min 2

Named Imports and Exports

Run a small multi-file JavaScript program

45 min

Module 14

Clean Code Foundations

Refine naming, responsibilities and duplication while preserving behavior.

Names That Explain Decisions

Choose names that communicate role and units

25 min 2

Small Functions with Clear Responsibilities

Judge function boundaries by meaning

30 min 3

Avoid Duplication without Overengineering

Share one business rule where it has one meaning

30 min 4

Separate Validation, Calculation and Presentation

Coordinate clear steps without mixing their responsibilities

40 min

Module 15

Testing Foundations

Derive meaningful expectations and protect behavior during changes.

What Is a Test?

Derive test cases from requirements

25 min 2

Basic Assertions and a Failing Test Run

Make a test failure observable

35 min 3

Testing Boundaries and Refactoring Safely

Build a compact test matrix

40 min

Module 16

Guided Mini Project

Complete the student report with validation, modules and executable tests.

Guided Project: Student Grade Management

Build a validated report from a written policy

2 to 3 hours

Module 17

Final Project

Independently build and test an order program from precise business rules.

Final Project: Mini Order Management System

Translate a small business brief into a tested modular program

4 to 6 hours

Module 18

Bonus: JavaScript Meets the Browser

Optional bonus: connect one button while keeping domain logic independent.

Bonus: JavaScript Meets the Browser

Distinguish domain logic from a browser interface

30 min