Big O describes how runtime scales with input size. Common complexities: O(1) constant — object property access, Map/Set get/has/add; O(n) linear — array forEach/map/filter, indexOf; O(log n) — binary search on sorted array; O(n log n) — Array.sort(); O(n^2) — nested loops. Space complexity similarly. In interviews: always state the complexity of your solution and why. Interviewer wants to hear 'this is O(n) time and O(1) space because...'. This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

Iterative: let prev = null, curr = head; while (curr) { let next = curr.next; curr.next = prev; prev = curr; curr = next; } return prev; — O(n) time, O(1) space. Recursive: function reverse(node, prev=null) { if (!node) return prev; let next = node.next; node.next = prev; return reverse(next, node); } — O(n) time, O(n) space (call stack). Iterative is preferred for large lists (no stack overflow risk). This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

Naive: nested loops O(n^2). Optimal O(n) with a hash set: const seen = new Set(); for (const num of nums) { const complement = target - num; if (seen.has(complement)) return [complement, num]; seen.add(num); } — One pass, O(n) time, O(n) space. For sorted array: two pointers O(n) time O(1) space — start at both ends, move inward based on sum vs target. This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

BST: left subtree < node < right subtree. Insert: compare with current node, go left if smaller, right if larger, insert when null. Search: same traversal, return true when found. class Node { constructor(val) { this.val=val; this.left=this.right=null; } } insert: if (!root) return new Node(val); if (val < root.val) root.left = insert(root.left, val); else root.right = insert(root.right, val); return root. Worst case O(n) for unbalanced tree; O(log n) balanced. This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

BFS (breadth-first): explores level by level using a queue. Use for: shortest path in unweighted graph, finding closest nodes, level-order traversal. DFS (depth-first): explores as deep as possible using a stack/recursion. Use for: detecting cycles, topological sort, exploring all paths, tree traversals (inorder, preorder, postorder). BFS implementation: const visited = new Set(); const queue = [start]; visited.add(start); while (queue.length) { const node = queue.shift(); for (const neighbor of graph[node]) { if (!visited.has(neighbor)) { visited.add(neighbor); queue.push(neighbor); } } } This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

DP: break problem into overlapping subproblems, solve each once and store results. Bottom-up coin change: given coins and amount, find minimum coins to make amount. function coinChange(coins, amount) { const dp = new Array(amount+1).fill(Infinity); dp[0] = 0; for (let i=1; i<=amount; i++) { for (const coin of coins) { if (coin <= i) dp[i] = Math.min(dp[i], dp[i-coin]+1); } } return dp[amount]===Infinity ? -1 : dp[amount]; } O(amount * coins.length) time. This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

Recursive: function flatten(arr) { return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flatten(val)) : [...acc, val], []); } Iterative (stack-based, avoids stack overflow for deeply nested): function flatten(arr) { const stack = [...arr]; const result = []; while (stack.length) { const item = stack.pop(); if (Array.isArray(item)) stack.push(...item); else result.push(item); } return result.reverse(); } This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

LRU evicts the least recently accessed item when capacity is reached. Optimal O(1) get and put: use a doubly linked list (order by recency) + HashMap (O(1) lookup). Get: if key in map, move node to front, return value. Put: if key exists, update and move to front. If at capacity, remove the tail (LRU). Add new node to front. In JS: use Map (insertion-ordered) as a shortcut — Map maintains insertion order, so delete+re-insert moves to end, and map.keys().next() gets the oldest. This gives O(1) operations. A practical answer should also mention how I would verify the choice, for example by checking query plans, measuring response time, or testing behavior under concurrent writes.

1. Browser checks DNS cache, then OS cache, then DNS resolver → gets IP address. 2. TCP handshake with the server (3-way: SYN, SYN-ACK, ACK). 3. TLS handshake for HTTPS (negotiates cipher, exchanges certificates, establishes encrypted channel). 4. HTTP GET request sent. 5. Server processes request, sends HTTP response with HTML. 6. Browser parses HTML, constructs DOM. 7. Encounters CSS → fetch, parse, construct CSSOM. 8. Encounter JS → fetch, parse, execute (may block parsing). 9. DOM + CSSOM → Render tree → Layout → Paint → Composite → Display. This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

CRP: the sequence DOM → CSSOM → Render tree → Layout → Paint before first pixel appears. CSS is render-blocking (browser won't paint until CSSOM is ready). JS is parser-blocking by default (stops HTML parsing). Optimizations: async/defer scripts (defer maintains order, doesn't block parsing), inline critical CSS (above-the-fold styles), preload important resources, minimize CSS files, avoid large layout-causing JS on initial load, use font-display: swap for web fonts. This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

HTTP/1.1: one request per TCP connection at a time (with keep-alive), text-based protocol, head-of-line blocking. HTTP/2: binary protocol, multiplexing (multiple requests over one connection simultaneously), header compression (HPACK), server push, stream prioritization. HTTP/3: uses QUIC (UDP-based) instead of TCP — eliminates TCP head-of-line blocking, faster connection establishment (0-RTT reconnect), better performance on lossy networks (mobile). Vercel and Cloudflare support HTTP/3. This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

A stack is LIFO: last in, first out. Operations are push and pop. Common uses: function call stack, undo history, DFS. A queue is FIFO: first in, first out. Operations are enqueue and dequeue. Common uses: task scheduling, BFS, message processing. Interviewers often care less about memorizing names and more about whether you can map the right structure to the right problem. This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

A collision happens when two keys map to the same bucket or index. Common strategies: separate chaining, where each bucket stores a list of entries, and open addressing, where the table probes for another empty slot. Good hash functions and resizing keep average operations near O(1), but worst case can degrade if collisions are excessive. In real systems, load factor and resize policy matter a lot. This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

Choose recursion when the problem is naturally recursive, such as tree traversal or divide-and-conquer, and the depth is safe. Choose iteration when you want tighter control over memory, avoid call-stack limits, or process large inputs reliably. Recursive code can be cleaner; iterative code is often safer in production JavaScript because deep recursion can overflow the stack. This matters because computer science fundamentals help explain why one solution is faster, safer, or more reliable than another. Even when the topic is browser or HTTP behavior, the goal is to explain the sequence clearly and connect it to debugging or performance.

SOLID is a set of design principles that help write clean and maintainable code.

• Single Responsibility → one class should have one responsibility
• Open/Closed → open for extension, closed for modification
• Liskov Substitution → child classes should behave like parent
• Interface Segregation → don’t force classes to implement unused methods
• Dependency Inversion → depend on abstractions, not concrete implementations

• Method Overloading is when you have multiple methods with the same name but different parameters (not supported in JavaScript).
• Method Overriding is when a subclass provides a specific implementation of a method that is already defined in its superclass.

Abstraction means hiding complex implementation details and exposing only what’s necessary.

Object-Oriented Programming (OOP) is a programming paradigm that organizes code around objects, which are instances of classes. The core principles of OOP are:

• Encapsulation: Bundling data and methods that operate on that data within a single unit (class).
• Inheritance: Creating new classes based on existing ones to promote code reusability.
• Polymorphism: Allowing objects of different classes to be treated as objects of a common superclass, typically through method overriding.
• Abstraction: Hiding complex implementation details and exposing only the necessary features to the user.

These principles help in creating modular, reusable, and maintainable code.