JavaScript & TypeScript Track

Welcome to the JS Track! This course focuses on JavaScript/TypeScript fundamentals and theory that are commonly tested in technical interviews. Unlike the DSA Track which focuses on coding problems, many questions here are conceptual — you'll need to explain how things work, not just write code.

What to Expect: Theory Problems

Throughout this track, you'll encounter a problem type labeled Theory. These are conceptual questions that test your understanding of JavaScript internals, not coding challenges.

How Theory Problems Work

Q: Explain the difference between `var`, `let`, and `const`. 
   What is the temporal dead zone?

Expected Answer:
- `var` is function-scoped, hoisted with undefined initialization
- `let` and `const` are block-scoped, hoisted but NOT initialized (TDZ)
- `const` must be initialized at declaration and cannot be reassigned
- Temporal Dead Zone: the period between entering a scope and the 
  variable declaration being executed, where accessing the variable 
  throws a ReferenceError

Why Theory Problems Matter

Many companies, especially for senior roles, test your understanding of JavaScript, not just your ability to use it:

• Phone Screens: Often start with conceptual questions
• System Design: Requires deep understanding of async patterns, memory management
• Debugging: Understanding internals helps you diagnose issues faster
• Senior Roles: Expected to mentor others and make architectural decisions

Prerequisites Check

Before starting this track, ensure you're comfortable with:

Essential JavaScript Basics

// Variables and Types
let name = "Alice";
const age = 30;
const isActive = true;
const items = [1, 2, 3];
const user = { name: "Alice", age: 30 };

// Functions
function greet(name) {
    return `Hello, ${name}!`;
}

const greetArrow = (name) => `Hello, ${name}!`;

// Conditionals and Loops
if (age >= 18) {
    console.log("Adult");
}

for (const item of items) {
    console.log(item);
}

items.forEach(item => console.log(item));

Array Methods You Should Know

const numbers = [1, 2, 3, 4, 5];

// Transformations
const doubled = numbers.map(n => n * 2);           // [2, 4, 6, 8, 10]
const evens = numbers.filter(n => n % 2 === 0);    // [2, 4]
const sum = numbers.reduce((acc, n) => acc + n, 0); // 15

// Searching
const found = numbers.find(n => n > 3);            // 4
const index = numbers.findIndex(n => n > 3);       // 3
const hasEven = numbers.some(n => n % 2 === 0);    // true
const allPositive = numbers.every(n => n > 0);     // true

// Spread and Destructuring
const copy = [...numbers];
const [first, second, ...rest] = numbers;          // 1, 2, [3,4,5]

If any of this is unfamiliar, that's okay! The Core Fundamentals module covers everything from the ground up.

Interview Approach for Conceptual Questions

When answering theory questions in interviews, follow this structure:

The STAR-T Framework for Theory Questions

S - State the Definition Start with a clear, concise definition. Don't ramble.

T - Technical Details Explain the underlying mechanism. Use precise terminology.

A - Analogies (Optional) If helpful, use a real-world analogy to clarify.

R - Real Example Provide a code example that demonstrates the concept.

T - Tradeoffs/Gotchas Mention common pitfalls, edge cases, or when NOT to use something.

Example: Explaining Closures

"A closure is when a function remembers variables from outside."

A Note on the Answers

Track Overview

Here's what you'll master in each module:

1. Core Fundamentals (Free)

The foundation of everything. You'll learn execution context, the call stack, hoisting, scope chains, closures, this binding, prototypes, and the event loop. These concepts appear in almost every JavaScript interview.

2. TypeScript Introduction

TypeScript is now expected at most companies. You'll learn the type system, generics, utility types, type guards, and how to leverage TypeScript for safer code. Essential for modern frontend development.

3. Frontend Development

Browser APIs, DOM manipulation, event handling, and web performance. Covers topics like reflows, repaints, event delegation, and the critical rendering path — common topics in frontend-focused interviews.

4. Advanced Concepts

Deep dives into advanced patterns: generators, iterators, proxies, metaprogramming, memory management, and design patterns. These separate senior candidates from mid-level ones.

How This Track Differs from DSA

Recommendation: Most candidates should do both tracks. The JS Track gives you the foundation; the DSA Track gives you the problem-solving skills.

Getting Started

Start with the Core Fundamentals module. These concepts are prerequisites for everything else and are the most commonly asked topics.

Each lesson includes:

• Conceptual explanations with visual diagrams
• Theory practice questions with expected answers
• Interview tips specific to each topic

Pro Tip: After learning a concept, try explaining it out loud as if you're in an interview. If you can teach it clearly, you understand it.

Good luck with your preparation!