Template syntax vs JSX: framework design trade-offs?
WHAT IT TESTS: understanding of language design choices and their implications. OUTLINE: templates (Vue, Angular) are declarative, easier to learn, enable static analysis; JSX (React, Solid) is code-based, flexible, familiar to JavaScript developers.
Server-side data fetching in Nuxt 3?
WHAT IT TESTS: understanding Nuxt's data fetching and SSR integration. OUTLINE: use useFetch or useAsyncData to fetch on server, data is serialized and injected into page state, component accesses it as reactive data.
AOT vs JIT compilation: what does ahead-of-time win?
WHAT IT TESTS: understanding of compilation strategies and their trade-offs. OUTLINE: AOT compiles templates at build time (catches errors early, smaller bundle, faster startup), JIT compiles in browser (slower startup, larger bundle, flexible).
Hydration: SSR HTML to interactive app?
WHAT IT TESTS: understanding server rendering and client takeover. OUTLINE: server renders HTML, client JavaScript bootstraps and attaches event listeners (hydration), mismatch occurs if server HTML differs from client render.
Testing shared Vue components: unit, a11y, visuals?
WHAT IT TESTS: ability to architect comprehensive component testing. OUTLINE: unit tests (Vitest/Jest) for logic, accessibility tests (axe, Pa11y) for ARIA/keyboard, visual regression (Percy, Chromatic) for rendering.
Zone.js and change detection optimization in Angular?
WHAT IT TESTS: understanding Angular's async tracking and performance tuning. OUTLINE: zone.js wraps async (timers, events, HTTP), triggering change detection after each; use runOutsideAngular when external libraries fire high-frequency events.
When to adopt Pinia or NgRx over simple services?
WHAT IT TESTS: judgment on when to add complexity. OUTLINE: services work for small apps; use Pinia/NgRx when state is shared across many components, mutations are complex, or debugging/undo matters. RED FLAG: premature adoption or dismissing stores entirely.
Compiler vs runtime reactivity: Svelte, Vue, Angular?
WHAT IT TESTS: deep understanding of framework architecture choices. OUTLINE: Svelte compiles away reactivity (smaller bundles, zero-cost), Vue/Angular use runtime Proxies/zone.js (flexible but heavier).
Compile-time vs runtime prop validation across frameworks?
WHAT IT TESTS: understanding of type safety mechanisms. OUTLINE: TypeScript (compile-time) catches errors before build; Vue props validation (runtime) catches at runtime; tradeoff: TS is stricter, Vue validation is flexible but less safe.
Content projection: slots vs props for composition?
WHAT IT TESTS: understanding of component composition models and when to use templating over data. OUTLINE: slots let parent pass markup (not data) to child, child renders it as-is, vs props pass values; slots excel when parent needs full layout control.
Prerendering vs SSR in SvelteKit: trade-offs?
WHAT IT TESTS: understanding of build-time vs request-time rendering and its implications. OUTLINE: prerender generates static HTML at build, SSR renders on each request, prerender wins on speed but requires static data.
What isolatedModules enforces and why bundlers need it
WHAT IT TESTS: Single-file transpilation constraints. OUTLINE: isolatedModules forbids features needing cross-file type info because Babel and esbuild compile each file alone; const enums, certain re-exports, and namespace tricks are flagged.
First compilerOptions to set after tsc --init
WHAT IT TESTS: Practical tsconfig priorities. OUTLINE: Enable strict for full type safety, set target and module to match the runtime, and choose outDir/rootDir or moduleResolution; each tightens checks or aligns output.
WebRTC signaling: SDP, ICE, and the signaling server
WHAT IT TESTS: WebRTC connection setup. OUTLINE: Peers exchange SDP offer and answer describing media via an out-of-band signaling server, then trade ICE candidates to find a network path using STUN and TURN.
Dedicated vs Shared vs Service Workers compared
WHAT IT TESTS: Browser worker types and roles. OUTLINE: Dedicated worker serves one page for offloading CPU; Shared worker is one instance across same-origin contexts via ports; Service worker is a network proxy for caching and push, event-driven and killable.
Generic merge with an intersection return type
WHAT IT TESTS: Generics and intersection types. OUTLINE: Use two type parameters T and U, return T & U, spread both objects; note later spread wins on key collisions and the type may not reflect that.
Promise .catch() versus async/await try...catch
WHAT IT TESTS: Async error-handling models. OUTLINE: .catch() handles rejection for all preceding chain steps and reads functionally; try/catch reads synchronously and can scope errors per await, but only catches awaited rejections.
Implementing the Singleton pattern in TypeScript
WHAT IT TESTS: Encapsulating single-instance access. OUTLINE: Private constructor blocks new, a static private instance field caches it, static getInstance lazily creates and returns the one instance.
Understanding this in TypeScript
In TypeScript, this is determined by how a function is called, not where it is defined; arrow functions capture the enclosing this lexically, and TypeScript adds optional this parameters to type-check the expected context at compile time.
Purpose of Outlet in React Router v6 nested routes
WHAT IT TESTS: Nested routing layout knowledge. OUTLINE: Outlet renders the matched child route inside a parent layout, enabling shared chrome with swappable content; configure nested routes and place Outlet where children render.