JavaScript & TypeScript Foundations
Master modern JavaScript ES2024, TypeScript 5, async/await, and professional tooling from first principles
The shared foundation for both the Node.js Backend and Frontend Engineering tracks. Build a complete, professional understanding of the JavaScript language and TypeScript type system before you write a single line of Express, React, Vue, or Angular code. This course covers JavaScript from variables and functions through closures, prototypes, Promises, and async/await, then TypeScript from basic types through generics, decorators, and strict mode tooling.
Course Prerequisites
- Basic computer literacy. No prior programming experience required.
Part of Academy Track:
What You Will Master
Curriculum Modules (5 Modules)
Explore the structured module breakdown, lesson outcomes, and practical lab exercises.
Module 1: JavaScript Core
6 Lessons • ~6.1 Study Hours (0.61 CEUs)Module 1: JavaScript Core. Understand where JavaScript runs, why TypeScript matters, and how this course connects to both the Node.js Backend and Frontend Engineering tracks.. Master var, let, and const, understand lexical scope, the temporal dead zone, and the hoisting behaviour that catches every beginner off guard.
Course Introduction — The JavaScript Ecosystem in 2024
Understand where JavaScript runs, why TypeScript matters, and how this course connects to both the Node.js Backend and Frontend Engineering tracks.
Variables, Scoping & Hoisting
Master var, let, and const, understand lexical scope, the temporal dead zone, and the hoisting behaviour that catches every beginner off guard.
Functions, Closures & Higher-Order Functions
Understand function declarations vs expressions, closure mechanics, and how higher-order functions like map, filter, and reduce are built.
Objects, Prototypes & the Prototype Chain
Deep dive into JavaScript's object model: property descriptors, prototype-based inheritance, Object.create, and the __proto__ vs prototype distinction.
this Binding & Execution Context
Master the four binding rules for this, understand why arrow functions don't have their own this, and fix the most common class method pitfalls.
Arrays & Functional Collection Patterns
Master array methods: map, filter, reduce, flatMap, find, some, every, sort. Build functional data pipelines without mutation.
Module 2: Modern JavaScript (ES6+)
6 Lessons • ~5.8 Study Hours (0.58 CEUs)Module 2: Modern JavaScript (ES6+). Write concise arrow function syntax, understand template literal expressions, and learn tagged template literals for DSL construction.. Extract values from arrays and objects with destructuring, merge collections with spread, and collect remaining arguments with rest parameters.
Arrow Functions & Template Literals
Write concise arrow function syntax, understand template literal expressions, and learn tagged template literals for DSL construction.
Destructuring, Spread & Rest
Extract values from arrays and objects with destructuring, merge collections with spread, and collect remaining arguments with rest parameters.
ES Modules — import & export
Understand named vs default exports, re-exports, dynamic import(), and how ES modules differ from CommonJS require() in a Node.js context.
Classes & OOP in JavaScript
Use ES6+ class syntax for object-oriented design: constructors, getters/setters, static methods, private fields (#), and class inheritance with super.
Optional Chaining, Nullish Coalescing & Logical Assignment
Write safer, more concise code with ?., ??, ??=, &&=, and ||= — the modern null-safety operators every JavaScript developer needs.
Iterators, Generators & Symbols
Understand the iteration protocol, write custom iterables, use generator functions for lazy evaluation, and understand how Symbols enable framework internals.
Module 3: Asynchronous JavaScript
5 Lessons • ~5.2 Study Hours (0.52 CEUs)Module 3: Asynchronous JavaScript. Understand how JavaScript achieves non-blocking concurrency with a single thread: the call stack, heap, task queue, microtask queue, and the event loop cycle.. Understand the callback pattern, why it was the original async model, and how deeply nested callbacks (callback hell) motivated the invention of Promises.
The Event Loop & JavaScript's Concurrency Model
Understand how JavaScript achieves non-blocking concurrency with a single thread: the call stack, heap, task queue, microtask queue, and the event loop cycle.
Callbacks & Callback Hell
Understand the callback pattern, why it was the original async model, and how deeply nested callbacks (callback hell) motivated the invention of Promises.
Promises — Chaining & Combinators
Master the Promise API: then/catch/finally chaining, Promise.all, Promise.allSettled, Promise.race, Promise.any — and how to avoid common Promise anti-patterns.
async/await & Error Handling
Write async code that reads like synchronous code. Master async functions, await expressions, try/catch with async, and patterns for parallel vs sequential async operations.
Fetch API & HTTP Data Fetching
Use the Fetch API to make HTTP requests, handle JSON responses, implement retry logic, use AbortController for cancellation, and understand fetch vs axios.
Module 4: TypeScript Foundations
6 Lessons • ~6.3 Study Hours (0.63 CEUs)Module 4: TypeScript Foundations. Understand TypeScript's value proposition, how type inference works, the difference between structural and nominal typing, and when to annotate vs let TypeScript infer.. Master TypeScript's type vocabulary: string, number, boolean, null, undefined, symbol, bigint, arrays, readonly arrays, tuples, const enums, and the never type.
Why TypeScript & Type Inference
Understand TypeScript's value proposition, how type inference works, the difference between structural and nominal typing, and when to annotate vs let TypeScript infer.
Primitive Types, Arrays, Tuples & Enums
Master TypeScript's type vocabulary: string, number, boolean, null, undefined, symbol, bigint, arrays, readonly arrays, tuples, const enums, and the never type.
Interfaces & Type Aliases
Define object shapes with interfaces and type aliases, understand when to use each, compose types with intersection (&) and union (|), and use index signatures.
Generics & Type Constraints
Write reusable, type-safe functions and classes using generics. Apply constraints with extends, use conditional types, mapped types, and utility types (Partial, Required, Pick, Omit, Record).
Type Narrowing & Discriminated Unions
Use type guards (typeof, instanceof, in), discriminated unions for exhaustive type dispatch, and the satisfies operator to write safer conditional code.
Decorators & Metadata Reflection
Understand TypeScript decorators — class, method, property, and parameter decorators — and how NestJS and Angular use them as the basis for their dependency injection systems.
Module 5: Tooling & Project Setup
4 Lessons • ~3.9 Study Hours (0.39 CEUs)Module 5: Tooling & Project Setup. Install and manage Node.js versions with nvm, understand the npm ecosystem, package.json scripts, semantic versioning, and why pnpm is the modern choice for monorepos.. Configure TypeScript's compiler options: strict mode, module resolution, target, lib, paths aliases, and how to structure tsconfig for monorepo workspaces.
Node.js, npm & pnpm Essentials
Install and manage Node.js versions with nvm, understand the npm ecosystem, package.json scripts, semantic versioning, and why pnpm is the modern choice for monorepos.
tsconfig.json & the TypeScript Compiler
Configure TypeScript's compiler options: strict mode, module resolution, target, lib, paths aliases, and how to structure tsconfig for monorepo workspaces.
esbuild & Modern Bundling
Use esbuild for blazing-fast TypeScript transpilation and bundling, understand the difference between transpilation and bundling, and compare esbuild, tsc, Vite, and tsx.
Testing with Vitest & ESLint
Write your first unit tests with Vitest (the modern Jest alternative), configure ESLint with typescript-eslint for code quality, and set up Prettier for consistent formatting.
Node.js Backend Progression
Continue advancing through the sequential curriculum stages of this academy track: