Advanced JavaScript Engineering 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 advanced JavaScript engineering course, the learner will be able to:
• Trace execution contexts, lexical environments, hoisting, the temporal dead zone and closure behaviour.
• Predict and prevent difficult type-coercion, equality and property-access bugs.
• Control object behaviour with property descriptors, prototypes, symbols and private state.
• Use `Proxy` and `Reflect` only where metaprogramming creates clear value.
• Reason about call-stack execution, promise jobs and asynchronous scheduling.
• Design bounded concurrency and dependable asynchronous error-handling patterns.
• Build composable synchronous and asynchronous data flows with advanced iterators and generators.
• Compare functional and object-oriented designs for a given domain problem.
• Identify performance bottlenecks through measurement and select suitable data structures and algorithms.
• Design, test, document and defend an extensible JavaScript architecture.

Modules

1. 1

   Execution model and lexical environments

   Parsing and execution at a practical conceptual levelExecution contexts and the call stackLexical environments and scope resolutionHoisting, function declarations and the temporal dead zoneClosures, retained state and accidental memory retentionStrict mode and module behaviour**Practice:** trace and repair scope, hoisting and closure defects
2. 2

   Types, coercion and equality

   Primitive values versus objectsBoxing and unboxingAbstract conversion at a useful engineering levelStrict equality, `Object.is` and SameValueZero behaviourNumeric edge cases: `NaN`, infinities, floating-point limits and `bigint`Defensive validation and explicit conversion**Practice:** harden a financial-calculation module built with fictional values
3. 3

   Object internals and metaprogramming

   Own and inherited propertiesEnumerability, ownership and property descriptorsGetters, setters and controlled mutationPrototype delegation and class internalsSymbols and well-known symbols`Proxy` and `Reflect`Private state and invariants**Practice:** build a validated configuration object with observable rule changes
4. 4

   Asynchronous scheduling and concurrency design

   Call stack, host scheduling and promise jobsMicrotask ordering and common timing surprisesPromise resolution, thenables and error propagationSequential, parallel and bounded-concurrency patternsTimeouts, cleanup and failure aggregation as design concernsPreventing floating promises and unhandled failures**Practice:** create and test a bounded transaction-processing queue using simulations only
5. 5

   Advanced iteration and data-flow design

   Custom iterator designGenerator delegation with `yield*`Sending values into generatorsAsync iterators and async generatorsLazy transformation pipelinesBackpressure as a design conceptResource cleanup with iterator return paths**Practice:** stream fictional regional records through a memory-conscious validation pipeline
6. 6

   Architecture and reusable abstractions

   Functional core and imperative shellComposition, dependency injection and policy objectsState machines for explicit business workflowsCommand and strategy patterns expressed in plain JavaScriptModule dependency direction and stable interfacesAvoiding premature abstraction**Practice:** design pluggable eligibility and pricing rules for several fictional African operating regions
7. 7

   Testing, correctness, security and performance

   Behaviour, boundary, invariant and regression testsTest doubles without excessive mockingDeterministic testing of asynchronous logicPrototype pollution and unsafe property mergingAlgorithmic complexity for everyday JavaScriptBenchmarking before optimisationMemory use, allocation patterns and practical profiling**Practice:** secure, profile and optimise a supplied rules engine while preserving behaviour
8. 8

   Capstone and engineering review

   Define architecture, invariants and extension pointsImplement configurable synchronous and asynchronous policiesBuild tests for correctness, failures and concurrency limitsBenchmark a critical data path and document the evidenceConduct an architecture and code-review defence**Capstone:** **Africa Multi-Region Transaction Rules Engine**