Intermediate JavaScript Programming in Uganda & Africa

Course outline and learning expectations

This is a tutor-led course. The outline shows what your tutor will cover; teaching materials and examinations are provided directly to enrolled students.

What you will learn

• By the end of this intermediate JavaScript programming course, the learner will be able to:
• Use lexical scope, closures and higher-order functions intentionally.
• Build predictable data pipelines with array methods and immutable-update patterns.
• Select `Object`, `Array`, `Map` or `Set` according to the problem.
• Explain `this`, prototypes, delegation and how JavaScript classes relate to the prototype chain.
• Choose composition or inheritance for a given program design.
• Divide a program into cohesive ES modules with clear public interfaces.
• Build and combine promises, use `async`/`await`, and handle asynchronous failures.
• Create and consume iterable sequences with iterators and generators.
• Write focused automated tests for normal cases, boundaries and failures.
• Refactor a multi-module JavaScript program without changing its behaviour.

Modules

1. 1

   Deeper functions, scope and closures

   Lexical scope and the scope chainClosures as retained stateCallbacks and higher-order functionsFunction factories and configurable behaviourPartial application and simple compositionAvoiding hidden shared state**Practice:** create configurable savings and commission calculators
2. 2

   Data transformation and collection choices

   Chaining `map`, `filter`, `reduce`, `flatMap`, `sort` and grouping operationsNon-mutating updates and defensive copyingShallow copies and nested-data risks`Map` and `Set` for lookup, counting and uniquenessTime and space trade-offs at a practical levelBuilding reusable transformation pipelines**Practice:** reconcile fictional payment records and detect duplicates
3. 3

   Objects, `this`, prototypes and classes

   Property lookup and the prototype chainMethod calls and the value of `this`Explicit binding with `call`, `apply` and `bind`Constructor functions and class syntaxPublic and private class fieldsComposition versus inheritance**Practice:** model accounts, transactions and policies without a user interface
4. 4

   Modules, contracts and dependable errors

   Named and default ES module exportsCohesion, coupling and module boundariesSeparating rules, data and presentationValidating function inputs and outputsCustom error classes and error propagationRefactoring a single large file into a small module system**Practice:** organise a stock and order-processing program
5. 5

   Promises and asynchronous JavaScript

   Synchronous versus asynchronous executionCreating, returning and chaining promisesPromise states and error propagation`async` functions and `await`Sequential versus concurrent work`Promise.all`, `allSettled`, `race` and `any`**Practice:** simulate delayed payment confirmations without networks or APIs
6. 6

   Iterables and generators

   Iterable and iterator protocolsHow `for...of` consumes iterablesGenerator functions and `yield`Lazy sequences and controlled data productionCustom iterablesWhen a generator improves clarity and when it does not**Practice:** process transaction batches without building unnecessary intermediate arrays
7. 7

   Testing, debugging and refactoring

   Arrange, act and assertUnit tests for pure functions and modulesBoundary cases, invalid data and error assertionsTesting asynchronous functionsDebugging closures, object state and promise chainsRefactoring duplication and overly complex conditions**Practice:** add a reliable test suite to an existing reconciliation program
8. 8

   Capstone and skills assessment

   Design module responsibilities and data contractsImplement synchronous and asynchronous rulesTest important behaviours and failure pathsReview readability, duplication and state managementExplain design choices in a structured code reviewEast Africa Delivery Pricing and Reconciliation Engine