Learning path
JavaScript & TypeScript learning path: everything to study, topic by topic
Comprehensive JS/TS assessment from core language mechanics through advanced type-level programming, runtime internals, and expert metaprogramming patterns.
Short answer
To learn JavaScript & TypeScript, work through 6 modules and 39 topics in the order they build on each other. It starts with JS Fundamentals, then moves on to Modern JavaScript and TypeScript Core. Use the map as a checklist, or measure your level and study only what is missing.
What you will study
Topics are grouped by module. Open one to see its objectives and key concepts.
1 · JS Fundamentals8 topics
Variables & Scoping
var/let/const, hoisting, block scope, function scope, temporal dead zone, and scope chain
Objectives
- Explain hoisting and the temporal dead zone
- Choose the correct variable declaration for each scenario
Key concepts
- var
- let
- const
- hoisting
- block scope
- temporal dead zone
- scope chain
Functions & Closures
Function declarations, expressions, arrow functions, closures, IIFE, and higher-order functions
Objectives
- Explain how closures capture variables
- Use higher-order functions effectively
Key concepts
- closure
- arrow function
- IIFE
- higher-order function
- lexical scope
- callback
Prototypes & this
Prototype chain, Object.create, constructor functions, this binding rules, and class syntax
Objectives
- Trace prototype chain lookups
- Predict the value of this in different contexts
Key concepts
- prototype chain
- __proto__
- Object.create
- new keyword
- this binding
- call/apply/bind
- class syntax
DOM & Events
DOM traversal, manipulation, event bubbling/capturing, delegation, and requestAnimationFrame
Objectives
- Explain event propagation phases
- Implement event delegation patterns
Key concepts
- DOM API
- event bubbling
- event capturing
- event delegation
- stopPropagation
- preventDefault
- requestAnimationFrame
Data Types Deep Dive
Primitive types, object type, typeof operator, null vs undefined, Symbol, BigInt, type coercion, and truthy/falsy values
Objectives
- Distinguish all primitive types from object types
- Predict type coercion outcomes in expressions
Key concepts
- primitive types
- object type
- typeof operator
- null vs undefined
- Symbol
- BigInt
- type coercion
- truthy and falsy
Equality & Comparisons
== vs ===, Object.is(), type coercion in comparisons, NaN equality, and reference vs value equality
Objectives
- Predict results of == and === for mixed types
- Explain when Object.is() differs from ===
Key concepts
- == vs ===
- Object.is()
- type coercion in comparisons
- NaN equality
- reference vs value equality
- abstract equality algorithm
- strict equality
Operators
Arithmetic, logical, nullish coalescing (??), optional chaining (?.), spread, destructuring, ternary, and bitwise operators
Objectives
- Apply nullish coalescing and optional chaining correctly
- Distinguish logical OR from nullish coalescing for default values
Key concepts
- arithmetic operators
- logical operators
- nullish coalescing (??)
- optional chaining (?.)
- spread operator
- destructuring assignment
- ternary operator
- bitwise operators
Strict Mode
'use strict' directive, implicit strict in modules, eliminated silent errors, this in strict mode, and reserved words
Objectives
- Explain what strict mode prevents and why it matters
- Identify code that behaves differently in strict mode
Key concepts
- 'use strict' directive
- implicit strict in modules
- eliminated silent errors
- this in strict mode
- undeclared variables
- duplicate parameters
- reserved words
2 · Modern JavaScript7 topics
ES6+ Features
Destructuring, spread/rest, template literals, symbols, iterators, generators, and optional chaining
Objectives
- Apply destructuring and spread in real code
- Use generators and iterators correctly
Key concepts
- destructuring
- spread operator
- rest parameters
- template literals
- Symbol
- iterator protocol
- generator
- optional chaining
Promises & Async/Await
Promise lifecycle, chaining, Promise.all/allSettled/race, async/await, and error propagation
Objectives
- Trace promise resolution order
- Handle errors correctly in async code
Key concepts
- Promise
- then/catch/finally
- Promise.all
- Promise.allSettled
- Promise.race
- async/await
- microtask queue
Modules & Bundling
ES modules, CommonJS, dynamic import, tree shaking, code splitting, and bundler configuration
Objectives
- Compare ES modules and CommonJS semantics
- Configure tree shaking and code splitting
Key concepts
- ES modules
- CommonJS
- dynamic import()
- tree shaking
- code splitting
- webpack
- Vite
- barrel files
Error Handling
try/catch/finally, custom errors, async error handling, error boundaries, and global handlers
Objectives
- Design robust error handling for async flows
- Create custom error hierarchies
Key concepts
- try/catch/finally
- custom Error classes
- unhandledrejection
- error boundaries
- Result pattern
- defensive programming
this Keyword
Global context this, method context, arrow function this, bind/call/apply, constructor this, and event handler this
Objectives
- Predict the value of this in any context
- Fix this-related bugs using bind, call, or arrow functions
Key concepts
- global context this
- method context this
- arrow function this
- bind/call/apply
- constructor this
- event handler this
- class context this
- this in callbacks
JavaScript Classes
Class syntax, constructor, extends, super, static methods, private fields (#), getters/setters, and class vs prototype
Objectives
- Design class hierarchies using extends and super
- Explain how class syntax maps to prototypes under the hood
Key concepts
- class syntax
- constructor method
- extends keyword
- super calls
- static methods
- private fields (#)
- getters and setters
- class vs prototype
Working with APIs
Fetch API, XMLHttpRequest, Request/Response objects, headers and CORS, AbortController, streaming responses, and FormData
Objectives
- Use the fetch API with proper error handling and CORS awareness
- Implement request cancellation with AbortController
Key concepts
- fetch API
- XMLHttpRequest
- Request/Response objects
- headers and CORS
- AbortController
- streaming responses
- FormData
- error handling patterns
3 · TypeScript Core4 topics
Type System
Structural typing, type inference, unions, intersections, literal types, and type narrowing
Objectives
- Explain structural vs nominal typing
- Use unions and intersections to model domains
Key concepts
- structural typing
- type inference
- union types
- intersection types
- literal types
- type narrowing
- never
- unknown
Interfaces & Generics
Interface declaration, extension, generic functions, generic constraints, and variance
Objectives
- Design reusable generic abstractions
- Apply constraints to generic parameters
Key concepts
- interface
- extends
- generic function
- generic constraint
- covariance
- contravariance
- default type parameter
Type Guards
typeof, instanceof, in operator, custom type predicates, discriminated unions, and assertion functions
Objectives
- Implement custom type predicates
- Use discriminated unions for safe branching
Key concepts
- typeof guard
- instanceof guard
- in operator
- type predicate
- discriminated union
- assertion function
- exhaustive check
Utility Types
Partial, Required, Pick, Omit, Record, Readonly, ReturnType, and custom utility types
Objectives
- Select the right utility type for a transformation
- Compose utility types to derive new types
Key concepts
- Partial
- Required
- Pick
- Omit
- Record
- Readonly
- ReturnType
- custom utility types
4 · Advanced TypeScript7 topics
Conditional Types
extends keyword in types, infer keyword, distributive conditionals, and recursive types
Objectives
- Build conditional types with infer
- Understand distributive behavior over unions
Key concepts
- conditional type
- infer keyword
- distributive conditional
- recursive type
- type distribution
- never filtering
Mapped Types
keyof, in operator in types, template literal types, remapping keys, and deep transformations
Objectives
- Create mapped types that transform object shapes
- Use template literal types for string manipulation
Key concepts
- mapped type
- keyof
- template literal type
- key remapping
- deep Partial
- modifiers (+/- readonly/optional)
Declaration Files
.d.ts authoring, module augmentation, global declarations, ambient modules, and DefinitelyTyped
Objectives
- Write declaration files for untyped libraries
- Augment existing module types safely
Key concepts
- .d.ts files
- declare keyword
- module augmentation
- global augmentation
- ambient module
- DefinitelyTyped
- triple-slash directives
Compiler Configuration
tsconfig.json, strict mode flags, project references, path aliases, and incremental builds
Objectives
- Configure tsconfig for large monorepos
- Explain the impact of each strict flag
Key concepts
- tsconfig.json
- strict mode
- strictNullChecks
- project references
- path aliases
- incremental builds
- composite projects
TypeScript Decorators
Decorator syntax (@), class/method/property/parameter decorators, decorator factories, metadata reflection, and stage 3 decorators
Objectives
- Implement custom decorators for cross-cutting concerns
- Explain the difference between legacy and stage 3 decorators
Key concepts
- decorator syntax (@)
- class decorators
- method decorators
- property decorators
- parameter decorators
- decorator factories
- metadata reflection
- stage 3 decorators
TypeScript Modules & Namespaces
ES modules in TS, declaration files (.d.ts), namespace keyword, module augmentation, ambient declarations, and barrel exports
Objectives
- Organize TypeScript code with modules and namespaces appropriately
- Configure path aliases and barrel exports for large projects
Key concepts
- ES modules in TS
- declaration files (.d.ts)
- namespace keyword
- module augmentation
- ambient declarations
- triple-slash directives
- barrel exports
- path aliases
TypeScript Build & Ecosystem
tsconfig.json, strict mode options, ESLint with TS, Prettier, build tools (tsc, esbuild, swc), project references, and incremental compilation
Objectives
- Configure a TypeScript project with modern build tools
- Choose the right build tool for different project requirements
Key concepts
- tsconfig.json
- strict mode options
- ESLint with TS
- Prettier integration
- build tools (tsc, esbuild, swc)
- project references
- declaration maps
- incremental compilation
5 · Runtime & Performance4 topics
Event Loop
Call stack, task queue, microtask queue, requestAnimationFrame timing, and Node.js event loop phases
Objectives
- Predict execution order across queues
- Explain Node.js event loop phases
Key concepts
- call stack
- task queue
- microtask queue
- requestAnimationFrame
- queueMicrotask
- Node.js phases
- setImmediate vs setTimeout
Memory Management
Garbage collection, memory leaks, WeakRef, FinalizationRegistry, heap snapshots, and profiling
Objectives
- Identify common memory leak patterns
- Use WeakRef and WeakMap to prevent leaks
Key concepts
- garbage collection
- mark-and-sweep
- memory leak patterns
- WeakRef
- WeakMap
- FinalizationRegistry
- heap snapshot
Web Workers
Dedicated workers, shared workers, service workers, transferable objects, and worker thread pools
Objectives
- Choose the right worker type for each use case
- Optimize data transfer between threads
Key concepts
- Web Worker
- SharedWorker
- Service Worker
- postMessage
- transferable objects
- structured clone
- worker_threads (Node.js)
V8 Optimization
Hidden classes, inline caching, JIT compilation tiers, deoptimization triggers, and performance profiling
Objectives
- Write code that enables V8 optimizations
- Identify patterns that cause deoptimization
Key concepts
- hidden classes
- inline caching
- Turbofan
- Sparkplug
- deoptimization
- monomorphic calls
- performance profiling
6 · Expert Patterns9 topics
Metaprogramming
Proxy, Reflect, Symbol.toPrimitive, decorators, and runtime code generation patterns
Objectives
- Build reactive systems with Proxy
- Apply decorators for cross-cutting concerns
Key concepts
- Proxy
- Reflect
- handler traps
- Symbol.toPrimitive
- decorators (TC39)
- runtime code generation
Advanced Async Patterns
Async iterators, AbortController, structured concurrency, backpressure, and observable patterns
Objectives
- Implement cancellable async operations
- Design backpressure-aware data pipelines
Key concepts
- async iterator
- for-await-of
- AbortController
- AbortSignal
- structured concurrency
- backpressure
- observable
Type-Level Programming
Recursive conditional types, type-level arithmetic, HKTs emulation, and branded types
Objectives
- Build recursive type-level utilities
- Emulate higher-kinded types in TypeScript
Key concepts
- recursive conditional type
- type-level arithmetic
- HKT emulation
- branded/opaque types
- variadic tuple types
- template literal parsing
Compiler Plugins & Tooling
TypeScript compiler API, custom transformers, AST manipulation, language service plugins, and codemods
Objectives
- Write custom TypeScript transformers
- Build codemods for large-scale refactors
Key concepts
- ts.Program
- custom transformer
- AST manipulation
- language service plugin
- ts-morph
- codemods
- Babel plugins
V8 Internals & JIT Optimization
Understanding V8's hidden classes, inline caches, and JIT compilation pipeline to write JIT-friendly JavaScript
Objectives
- Explain how V8 hidden classes affect property access performance
- Identify code patterns that cause JIT deoptimization
Key concepts
- hidden classes
- monomorphic vs polymorphic ICs
- JIT compilation
- deoptimization
- Turbofan
- Ignition
- shapes/maps
Advanced TypeScript Type System
Conditional types, mapped types, template literal types, infer keyword, and type-level programming
Objectives
- Use the infer keyword inside conditional types to extract type components
- Build a type-safe utility using template literal and mapped types
Key concepts
- conditional types
- mapped types
- infer
- template literal types
- variadic tuple types
- distributive conditionals
- type predicates
Module Federation & Micro-Frontends
Implementing micro-frontend architectures using Webpack Module Federation and shared dependency management
Objectives
- Configure a host and remote app using Webpack Module Federation
- Manage shared dependency versions to prevent runtime conflicts
Key concepts
- Module Federation plugin
- remote and host apps
- shared modules
- version conflicts
- runtime integration
- build-time vs runtime sharing
Build Tool Internals (Vite/esbuild)
Understanding how modern bundlers like Vite and esbuild work: plugin systems, tree-shaking, code splitting
Objectives
- Explain why Vite uses ESM natively in dev and Rollup in production
- Write a simple esbuild plugin to transform a custom file type
Key concepts
- ESM native dev
- tree shaking
- code splitting
- Rollup plugin API
- esbuild plugins
- HMR protocol
- bundle analysis
JavaScript Security at Depth
Prototype pollution, CSP configuration, DOM XSS sinks, supply chain attacks, and secure coding patterns in JS/TS
Objectives
- Identify and mitigate prototype pollution vulnerabilities in JS libraries
- Configure a Content Security Policy to prevent DOM-based XSS
Key concepts
- prototype pollution
- CSP directives
- DOM XSS sinks
- object.freeze
- supply chain risks
- Subresource Integrity
- eval avoidance
Levels: Junior, Mid, Senior, and Expert
Explain it in your own words
Graded by AI · no account · 1 questionNo options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.
Already studying JavaScript & TypeScript?
The assessment measures topic by topic, and your plan skips what you already know.
Open to read. An account is only needed to be measured.
Frequently asked questions
Where should I start studying JavaScript & TypeScript?
Start with JS Fundamentals: Variables & Scoping, Functions & Closures, and Prototypes & this. The map orders topics by what they depend on, so each one prepares the next.
How long does a full JavaScript & TypeScript assessment take?
A full assessment of this path takes about 45 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.
Do I need an account to use this page?
No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.