Advanced JavaScript Course

Lesson 1 • JIT Compilation and Optimisation Tiers

Examine Ignition bytecode and TurboFan optimising compiler. Reveals how hot functions get optimised and what triggers deoptimisation.

Lesson 2 • Event Loop and Task Queues

Map the full event loop: call stack, microtask queue, macrotask queue, and render steps. Explains async execution order precisely.

Lesson 3 • Parsing and Abstract Syntax Trees

Trace source code through lexing, tokenisation, and AST construction. Understanding this pipeline explains why syntax choices affect parse time.

Lesson 4 • Garbage Collection Strategies

Covers generational GC, mark-and-sweep, and incremental collection. Enables writing code that minimises GC pauses in production.

Lesson 1 • TypeScript Integration for JS Experts

Apply advanced TypeScript generics, conditional types, and mapped types to JavaScript projects. Bridges dynamic JS patterns with static analysis benefits.

Lesson 2 • Type Coercion and Abstract Operations

Dissect ToPrimitive, ToNumber, ToString, and ToBoolean algorithms. Eliminates coercion surprises by understanding the spec-level rules.

Lesson 3 • Runtime Type Checking Patterns

Build robust runtime validators using discriminated unions, branded types, and schema libraries. Complements static types with production-safe guards.

Lesson 4 • Prototype Chain and Inheritance

Trace property lookup through the prototype chain and understand [[Prototype]] linkage. Foundation for class syntax, mixins, and delegation patterns.

Lesson 1 • Module Systems and Encapsulation

Compare CommonJS, AMD, and ES Modules at the spec level including live bindings and circular dependency behaviour. Enables correct module architecture decisions.

Lesson 2 • Advanced Hoisting and TDZ

Distinguish var hoisting from let/const TDZ and function declaration hoisting. Prevents subtle initialisation-order bugs in complex codebases.

Lesson 3 • Closure Internals and Patterns

Examine how closures retain references to outer environments and apply them to factory functions and memoisation. Builds practical encapsulation skills.

Lesson 4 • Lexical Scope and Scope Chain

Trace identifier resolution through nested lexical environments. Explains why closures capture variables, not values, at definition time.

Lesson 1 • Observables and Reactive Streams

Model push-based async with Observable pattern and reactive operators. Complements Promises for multi-value, cancellable, composable async streams.

Lesson 2 • Callback Patterns and Inversion of Control

Analyse callback-based APIs, error-first conventions, and inversion-of-control problems. Establishes why Promises were necessary and how to wrap legacy APIs.

Lesson 3 • Async/Await and Error Handling

Desugar async/await to generator-based coroutines and master error propagation. Produces readable async code with airtight exception handling.

Lesson 4 • Promise Internals and Chaining

Trace Promise state machine, resolution handlers, and chaining mechanics. Enables writing correct multi-step async flows without hidden bugs.

Lesson 1 • Reflect API and Forwarding

Use Reflect methods to forward operations inside Proxy traps correctly. Ensures spec-compliant behaviour when building transparent proxy wrappers.

Lesson 2 • Custom Iterables and Protocols

Implement iterable, iterator, and async iterable protocols on custom objects. Integrates user-defined data structures with for-of, spread, and destructuring.

Lesson 3 • Property Descriptors and Object Internals

Manipulate writable, enumerable, configurable attributes and define getters/setters. Foundation for all metaprogramming that controls object behaviour.

Lesson 4 • Decorators and Class Metadata

Apply TC39 stage-3 decorators to classes, methods, and fields for cross-cutting concerns. Enables AOP-style logging, validation, and dependency injection.

Lesson 1 • Algorithmic Complexity and Data Structures

Select Map, Set, TypedArray, and custom structures for optimal time and space complexity. Replaces naive object usage with appropriate built-in structures.

Lesson 2 • Profiling and Measurement Methodology

Use browser DevTools flame charts, performance marks, and benchmarking harnesses correctly. Establishes measurement-first discipline before any optimisation attempt.

Lesson 3 • Rendering and Main Thread Optimisation

Offload work with Web Workers, schedule with scheduler API, and batch DOM mutations. Keeps main thread responsive under heavy computational load.

Lesson 4 • Memory Leak Detection and Prevention

Identify detached DOM nodes, forgotten timers, and closure-retained references using heap snapshots. Prevents long-session memory growth in SPAs.

Lesson 1 • Application Architecture Strategies

Compare MVC, MVVM, Flux, and event-sourcing architectures for frontend and Node.js apps. Guides architectural decisions based on team size and domain complexity.

Lesson 2 • Functional Programming Patterns

Apply pure functions, immutability, functor, monad, and transducer patterns in JavaScript. Enables composable, testable data transformation pipelines.

Lesson 3 • Behavioural Patterns and Communication

Implement Observer, Mediator, Command, and Strategy patterns for decoupled component communication. Reduces coupling in event-driven architectures.

Lesson 4 • Structural Patterns and Composition

Use Decorator, Proxy, Adapter, and Composite patterns to compose behaviour without deep inheritance. Reinforces composition-over-inheritance principle.

Lesson 1 • Static Analysis and Code Quality

Configure linters, type checkers, and complexity analysers as CI gates. Enforces consistent quality standards across large teams automatically.

Lesson 2 • JavaScript Security Vulnerabilities

Identify and mitigate XSS, prototype pollution, injection, and supply-chain risks in JS code. Applies threat modelling to client and server JavaScript contexts.

Lesson 3 • Observability and Error Monitoring

Instrument applications with structured logging, distributed tracing, and error boundary patterns. Enables rapid diagnosis of production incidents in complex JS systems.

Lesson 4 • Property-Based and Mutation Testing

Generate hundreds of test cases automatically with property-based testing and validate suite quality with mutation testing. Exposes edge cases missed by example-based tests.