Programming Languages & Core Development Topics
Programming languages, development fundamentals, coding concepts, and core data structures. Includes syntax, algorithms, memory management at a programming level, asynchronous patterns, and concurrency primitives. Also covers core data manipulation concepts like hashing, collections, error handling, and DOM manipulation for web development. Excludes tool-specific proficiency (see 'Tools, Frameworks & Implementation Proficiency').
Asynchronous and Event-Driven Programming
The programming model of a single asynchronous runtime: callbacks, promises and futures, async/await, event loops and task/microtask scheduling (including microtask starvation and where rendering fits), reactive streams and back-pressure, and how ordering, cancellation, timeouts, retries and error propagation behave across JavaScript, Node.js, mobile coroutine or async runtimes, and a comparison with Python asyncio and Java futures. Includes the async mechanics of a data fetch such as parallel versus sequential requests, partial failure, stale or out-of-order responses, abort, debounced live search, single-flight token refresh, and bounded concurrency; wrapping callback APIs as promises, streaming work through async consumers, moving heavy work off the main thread and back, and diagnosing unhandled rejections, race conditions and leaked subscriptions. Excludes message-queue and pub/sub system design, server throughput and thread-pool tuning, per-language threading and memory models, rebuilding standard APIs from scratch, and fetch caching or state architecture.
Functional Programming
Functional programming as a paradigm and a way of structuring code: pure functions and side-effect isolation (a pure core with effects at the edges, and how effects are described versus run), immutability and persistent data structures with structural sharing, updating nested immutable data including lenses, higher-order functions, function composition, currying and partial application, folds and recursion over data (including tail recursion), algebraic data types and pattern matching, total functions and Maybe/Either style error values, functors, applicatives and monads as patterns for composing effects and threading state, parser combinators as a worked example, lazy evaluation and lazy or streaming pipelines, and property-based testing of pure code. Covers reasoning about programs as composed transformations rather than mutable state, in a dedicated functional language such as Haskell or Scala, or in a multi-paradigm language such as JavaScript, TypeScript, Kotlin or Python. Boundary: closures and the this binding as language mechanics, the event loop and reactive streams, threads and STM-style concurrency, performance profiling, and exception or resource handling are covered elsewhere.
Programming Fundamentals
Language-agnostic building blocks of writing code: variables, primitive and composite data types, scope and lifetime, functions and callbacks, control flow, and expressions versus statements. Covers the mental model a candidate needs before any language-specific or algorithmic depth. The baseline literacy layer of a technical screen.
Error Handling and Defensive Programming
Making code robust against bad input and failure: exceptions versus error returns, input validation, guard clauses, graceful degradation, and designing for the unhappy path. Covers where to handle versus propagate errors and how to fail safely without hiding bugs. A recurring probe of production maturity.
JavaScript and TypeScript Fundamentals
The JavaScript and TypeScript language surface: scope and closures (including stale values captured in callbacks and what a closure keeps reachable), hoisting and the temporal dead zone, the this binding and method borrowing, prototypes and class inheritance, the object model (property descriptors, key enumeration order, freeze and seal, Map, Set, WeakMap, WeakRef, serialising Map and Set), number precision and BigInt, destructuring and modern ES syntax and modules, how JSX and newer syntax are transpiled and which gaps need polyfills, and the TypeScript type system (generics, narrowing, utility, mapped and discriminated-union types, typing component props, hooks, fetch wrappers and event emitters, validating untyped JSON, migrating a codebase to TypeScript). Covers language mechanics independent of any framework, in the browser and in Node.js. Event-loop and promise mechanics, rebuilding standard utilities from scratch, the functional paradigm, DOM and browser APIs, rendering performance, memory-leak diagnosis, and generic algorithm exercises are covered elsewhere.
Polyfills and JavaScript Utility Implementation
Rebuilding standard JavaScript behavior and common utility libraries from scratch, the machine-coding interview genre where a candidate re-creates a familiar API to prove they understand its mechanics. Covers a minimal Promise built from first principles (chaining, asynchronous handlers, single settlement, thenable adoption, error flow) and Promise.allSettled-style combinators; polyfills for browser APIs such as IntersectionObserver, and a keyed virtual DOM diff; utilities such as debounce (leading and trailing, cancel, flush), throttle, and React hooks that debounce a value or a callback with stable identity and no stale closures; deep clone (cycles, shared references, Dates, RegExps), shallow and deep equality (typed arrays, Maps and Sets, NaN and -0), nested object helpers (safe path get, flatten and unflatten, deep merge), curry with placeholders and partial application, and memoize with cache keys and WeakMap-based caches; and small infrastructure such as event emitters (on, off, once, emit, context binding, listener leaks). Emphasizes edge cases, correct this binding, argument handling, spec fidelity, and complexity. Using these built-ins as a language feature, the event loop and async/await semantics, DOM traversal and event propagation, functional programming as a paradigm, and generic algorithm puzzles are covered elsewhere.
Clean Code, Refactoring, and Maintainability
Writing code that other people can read, change, and keep alive over time: naming, function and module decomposition, avoiding duplication, readability, disciplined use of language idioms and design patterns, and recognizing code smells, extending into working effectively in large, aging, or unfamiliar codebases through safe incremental change, refactoring under test coverage, and managing technical debt. Covers both authoring professional-grade code beyond mere correctness and improving code you cannot rewrite without breaking it. Spans the coding-round quality signal and the seniority signal of leaving a codebase healthier than you found it.
Debugging and Performance Optimization
Finding and fixing what is wrong or slow: systematic debugging strategies, reading stack traces, profiling to locate hotspots, and optimizing execution time and memory. Covers reasoning from symptom to root cause and measuring before optimizing, including runtime, memory, and profiling analysis. Tests how a candidate operates on code they did not write.
Object-Oriented Programming and Design
The object-oriented paradigm: classes and objects, encapsulation, inheritance, polymorphism, and composition, plus SOLID and other design principles that keep object models maintainable. Covers modeling a domain in objects and defending those design choices. A staple conceptual interview across most engineering roles.