System Design Questions

Arrays store elements contiguously (O(1) random access, O(n) insert/delete). Linked lists store nodes with pointers (O(n) access, O(1) insert/delete at known position).

Big O describes how runtime grows with input size, ignoring constants. O(n log n) is the time for efficient sorts (merge, heap, quick on average) and divide-and-conquer algorithms.

A hash table maps keys to array indices via a hash function, giving O(1) average lookups. Collisions are handled by chaining (linked list per bucket) or open addressing (probe next slot).

BFS uses a queue, explores level-by-level, finds shortest path on unweighted graphs. DFS uses a stack (or recursion), goes deep first, used for topological sort, cycle detection, backtracking.

DP solves problems with overlapping subproblems and optimal substructure by solving each subproblem once and storing the result. Identify it when a recursive solution recomputes the same subproblems.

Stack is LIFO (push/pop at one end). Queue is FIFO (enqueue at back, dequeue from front). Stack: function calls, undo. Queue: BFS, scheduling, buffers.

Merge sort is stable and guaranteed O(n log n), preferred for linked lists and external sorting. Quicksort is in-place and faster in practice but O(n²) worst case and not stable.

Two pointers iterate through data with two indices moving at different speeds or from different ends. Works on sorted arrays (pair sum), for in-place operations (reverse), and cycle detection (Floyd's).

Use a token bucket algorithm: each user has a bucket refilling at rate r with capacity b. Each request consumes a token; if empty, reject. For distributed systems, store counters in Redis with atomic Lua scripts.

In a distributed system during a network partition, you must choose between Consistency (all nodes see same data) and Availability (every request gets a response). You can't have both. Partition tolerance is mandatory.

Vertical scaling hits limits. Horizontal: sharding (split by key), replication (reads to replicas), caching (Redis), async writes (queue + batch), denormalization. Choose write-optimized DB (Cassandra).

Stateless services don't store client data between requests — any instance can handle any request (easy to scale). Stateful services remember client state — requires sticky sessions or shared state.

INNER JOIN returns only rows that match in both tables. LEFT JOIN returns all rows from the left table, with NULLs for non-matching right-table columns.

Normalization organizes tables to reduce redundancy. 3NF means: the table is in 2NF, and no non-key column depends on another non-key column (no transitive dependencies).

Use NoSQL when: you need horizontal scaling beyond one machine, schema is flexible, data is hierarchical (documents), or access patterns are simple key lookups. Use SQL for relational data, complex queries, strong consistency.

An index is a separate data structure (usually B-tree) that maps column values to row locations, enabling O(log n) lookups instead of O(n) full scans. Trade-off: faster reads, slower writes, extra storage.

Atomicity (all-or-nothing), Consistency (valid state transitions), Isolation (concurrent transactions don't interfere), Durability (committed data survives crashes). Relational DBs guarantee these; most NoSQL relaxes them.

== does loose comparison with type coercion (5 == '5' is true). === does strict comparison without coercion (5 === '5' is false). Always use === to avoid surprises.

JS is single-threaded. The event loop checks: is the call stack empty? If yes, take callbacks from microtask queue (Promises), then macrotask queue (setTimeout, I/O), and run them. This enables async non-blocking I/O.

A closure is a function that remembers variables from its lexical scope, even after the outer function returns. Used for data privacy, currying, and function factories.

var is function-scoped and hoisted. let and const are block-scoped with a temporal dead zone. const can't be reassigned (but objects can be mutated). Use const by default, let when reassigning, never var.

A Promise represents a future value — pending, fulfilled, or rejected. async/await is syntactic sugar over Promises, letting you write async code that looks synchronous. await pauses until Promise resolves.

The Virtual DOM is a lightweight JS representation of the real DOM. React diffs new VDOM against previous (reconciliation), then applies only changed parts to real DOM — minimizing expensive DOM operations.

Hooks let function components use state and lifecycle. useState adds local state. useEffect runs side effects after render (data fetching, subscriptions, DOM manipulation).

useMemo memoizes a computed value (avoid recompute). useCallback memoizes a function (stable reference for child props). Use when computation is expensive or value/function is passed to memoized child. Don't overuse.

Lists are mutable (can add/remove/change) — [1,2,3]. Tuples are immutable — (1,2,3). Tuples are slightly faster, can be dict keys, and signal 'fixed collection'. Lists are for collections that change.

A decorator is a function that takes another function and extends its behavior without modifying it. Used for logging, timing, auth, caching. Syntax: @decorator above the function.

Interfaces define a contract (methods, no implementation pre-Java 8). Abstract classes can have fields, constructors, and method implementations. A class can implement multiple interfaces but extend only one abstract class.

HashMap uses an array of buckets. hash(key) % length determines bucket. Each bucket is a linked list (or red-black tree since Java 8 if > 8 entries). On collision, entries chain. When load factor > 0.75, array doubles and rehashes.

A process is an independent program with its own memory. A thread is a unit within a process — threads share memory but have separate stacks. Processes are heavier; threads are lighter.

A deadlock occurs when threads each hold a resource the other needs, blocking forever. Four conditions: mutual exclusion, hold-and-wait, no preemption, circular wait. Prevent by breaking any — usually lock ordering.

Browser parses URL → DNS lookup → TCP handshake → TLS handshake → HTTP request → server processes → HTTP response → browser renders. Dozens of steps in milliseconds.

HTTP/1.1: text, one request per connection. HTTP/2: binary, multiplexed streams, header compression. HTTP/3: over QUIC (UDP), no head-of-line blocking, faster setup.

Encapsulation (hide internal state), Abstraction (expose only essential behavior), Inheritance (derive new classes from existing), Polymorphism (same interface, different implementations).

Inheritance is 'is-a' (Dog is an Animal). Composition is 'has-a' (Car has an Engine). Prefer composition — more flexible (swap at runtime), avoids deep hierarchies, doesn't break when parent changes.

Use STAR: Situation, Task, Action, Result. Pick a bug showing debugging skill, persistence, and impact. Quantify the result.

Listen first, find common ground, use data over opinions, propose experiments if unclear, defer to team if tie. Never make it personal. Document the decision (ADR).

Frame positively — focus on what you're moving toward (growth, new challenges), not escaping. Never badmouth. Keep brief and pivot to why this role excites you.