Topic bank

Curate what you get quizzed on. Categories set the mix (e.g. 20% RL, 30% C++); topics carry their own weight within a category. Weights are relative — they don't need to add up to 100.

Add a category

25% of mix 30 topics
Build / ABI Compilation pipeline, linking, libraries, and ABI compatibility Explain preprocessing, compilation, assembly, linking, static vs shared libraries, symbol visibility, name mangling, and ABI breaks Linker errors, runtime shared-library mismatch, ABI-incompatible compiler flags w 1
Compilation Translation units, headers, linkage, ODR, and modules Know declarations vs definitions, internal/external linkage, inline, static, anonymous namespaces, header guards, and One Definition Rule violations Duplicate symbols, missing symbols, ODR violations, excessive rebuilds, macro leakage w 1
Concurrency Async, futures, thread pools, and task-based design Compare std::async, futures/promises, packaged_task, coroutines, thread pools, and work stealing at a conceptual level Oversubscription, hidden blocking, unbounded task queues, poor cancellation handling w 1
Concurrency Atomics and the C++ memory model Explain data races, happens-before, acquire/release, relaxed ordering, sequential consistency, fences, and lock-free tradeoffs Using volatile for synchronization, broken double-checked locking, relaxed-ordering bugs w 1
Concurrency Threads, mutexes, locks, and condition variables Understand std::thread, jthread, mutex, lock_guard, unique_lock, condition_variable, spurious wakeups, and cancellation basics Deadlocks, missed wakeups, forgetting predicate loops, joining/detaching mistakes w 1
Coroutines C++20 coroutines and asynchronous control flow Understand coroutine frames, co_await/co_yield/co_return, promise_type, suspension points, lifetime, and executor integration Dangling coroutine handles, leaked frames, blocking inside async code, unclear ownership w 1
Design API design, idioms, and professional C++ style Apply const-correctness, RAII, value semantics, dependency boundaries, pImpl, noexcept where useful, minimal ownership exposure, and testable interfaces Leaky abstractions, unclear ownership, over-template APIs, inheritance where composition fits better w 1
Error Handling Alternative error handling: std::optional, expected, variant, error_code Compare exceptions with value-based errors; model absence, recoverable failure, sum types, and API ergonomics Ignoring errors, abusing optional for diagnostics, unclear ownership of error state w 1
Error Handling Exceptions and exception safety Know stack unwinding, noexcept, strong/basic/no-throw guarantees, RAII interaction, exception-neutral code, and when exceptions are inappropriate Throwing from destructors, broken invariants after partial failure, missing noexcept on moves w 1
Language Model Object lifetime, storage duration, and initialization Understand stack/static/thread/dynamic storage, lifetime vs scope, initialization order, zero/default/value/list initialization, and static initialization order issues Use-before-lifetime, dangling references, static initialization order fiasco, uninitialized members w 1
Language Model References, pointers, const, and pointer qualifiers Distinguish pointer-to-const, const-pointer, references, nullability, aliasing, ownership vs observation, and API design implications Returning pointers to locals, confusing const T* vs T* const, assuming references can be reseated w 1
Language Model Value categories: lvalue, rvalue, xvalue, prvalue, glvalue Explain how value categories affect overload resolution, move semantics, references, temporaries, and return-value optimization Binding wrong reference type, accidental copies, dangling temporaries, misunderstanding std::move w 1
Memory Copy control: rule of 0, 3, 5 Understand destructor, copy/move constructor, copy/move assignment, self-assignment, exception safety, and when defaults are correct Double-free from shallow copy, suppressed move operations, broken assignment operator w 1
Memory Manual memory management: new/delete, malloc/free, alignment Know allocation vs construction, deallocation vs destruction, array delete, placement new, over-aligned types, and why malloc is usually wrong for C++ objects Memory leaks, double delete, mismatched new/delete, skipped constructors/destructors w 1
Memory RAII and deterministic destruction Explain why resource lifetime should be tied to object lifetime; apply RAII to files, locks, sockets, heap memory, GPU handles, and transactions Resource leaks on exceptions, forgetting unlock/close, partially constructed objects w 1
Memory Smart pointers and ownership models Compare unique_ptr, shared_ptr, weak_ptr, raw pointers, observer pointers, factory ownership, and shared ownership costs Cyclic shared_ptr leaks, overusing shared_ptr, returning raw owning pointers, bad custom deleters w 1
Move Semantics std::move, forwarding references, and perfect forwarding Explain std::move as a cast, std::forward, T&& deduction, universal/forwarding references, and when moving is valid Using moved-from objects incorrectly, moving const objects, over-forwarding, dangling references w 1
Object Model Casts: static_cast, dynamic_cast, const_cast, reinterpret_cast Explain what each cast promises, runtime checks, type punning constraints, strict aliasing, and safe alternatives Undefined behavior from reinterpret_cast, unsafe downcast, casting away const on truly const object w 1
Object Model Classes, structs, invariants, encapsulation, and constructors Design classes that preserve invariants; know explicit constructors, member initialization lists, delegating constructors, and default member initializers Two-phase initialization bugs, implicit conversions, uninitialized fields, invalid object states w 1
Object Model Inheritance, virtual dispatch, and polymorphism Understand vtables conceptually, virtual destructors, override/final, abstract classes, interface design, and runtime polymorphism costs Deleting derived via non-virtual base destructor, object slicing, hidden overloads, fragile base classes w 1
Object Model Multiple inheritance, virtual inheritance, and object layout Know when MI is safe, diamond inheritance, virtual base classes, pointer adjustment, ABI/layout implications Diamond ambiguity, unexpected object size, incorrect casts, constructor-order confusion w 1
Performance Cost model: copies, allocation, cache, branch prediction, inlining Reason from generated work: object size, heap allocation, virtual calls, cache locality, move/copy cost, false sharing, small-object optimization Premature abstraction overhead, allocation-heavy hot paths, poor data layout, accidental copies w 1
Performance Profiling, benchmarking, and optimization discipline Use profilers and microbenchmarks correctly; understand warmup, compiler optimization, dead-code elimination, CPU counters, and measurement noise Optimizing unmeasured code, invalid benchmarks, debug-build conclusions, ignoring cache effects w 1
Standard Library Algorithms, ranges, and iterator categories Use standard algorithms over hand-written loops; understand input/forward/bidirectional/random-access/contiguous iterators and lazy range pipelines Invalid range views, dangling views, assuming all iterators are random access, mutation during iteration w 1
Standard Library Containers and iterator invalidation Compare vector, deque, list, map, unordered_map, set, span, array; know complexity, memory layout, cache behavior, and invalidation rules Dangling iterators, poor container choice, accidental O(n²), unordered_map rehash bugs w 1
Strings and Views std::string, string_view, span, and non-owning views Understand ownership vs view semantics, null termination, lifetime constraints, encoding assumptions, and API design with views Dangling string_view/span, modifying through invalid view, assuming string_view owns memory w 1
Templates Function and class templates Understand template instantiation, deduction, specialization, overload resolution, and compile-time code generation Template bloat, confusing deduction failures, accidental overload selection w 1
Templates Metaprogramming fundamentals Know constexpr, consteval, if constexpr, type traits, integral_constant, variadic templates, fold expressions, and compile-time computation Recursive template explosion, runtime work mistaken for compile-time, hard-to-debug instantiations w 1
Templates SFINAE, concepts, and constraints Explain substitution failure, requires clauses, type traits, enable_if, and why concepts improve diagnostics and API intent Overly broad templates, unreadable errors, ambiguous constraints, unintended matches w 1
Undefined Behavior Undefined, unspecified, and implementation-defined behavior Recognize UB sources: signed overflow, out-of-bounds, dangling refs, strict aliasing, data races, invalid lifetime, unsequenced modification “Works on my machine” bugs, optimizer-induced surprises, release-only failures w 1
25% of mix 30 topics
Alignment / Preferences Preference optimization, RLHF, DPO-style objectives, and reward models Connect preference likelihoods, implicit rewards, KL regularization, reference models, reward hacking, and when direct optimization differs from RL Length bias, reward overoptimization, preference data artifacts, reference-policy dependence w 1
Architectures MLPs, CNNs, residual networks, normalization, and initialization Understand inductive biases, receptive fields, skip connections, BatchNorm vs LayerNorm/RMSNorm, initialization variance, and signal propagation Vanishing/exploding activations, train/eval BatchNorm mismatch, dead ReLUs, unstable deep nets w 1
Architectures Transformers and attention mechanisms Explain self-attention, Q/K/V, softmax attention, positional encoding, causal masking, multi-head attention, MHA/MQA/GQA, and KV cache behavior Quadratic context cost, attention sink issues, positional extrapolation failure, cache memory blowup w 1
Data Data curation, leakage, labeling noise, imbalance, and active learning Understand deduplication, train/test contamination, weak supervision, noisy labels, class imbalance, hard-negative mining, and data-centric iteration Label leakage, duplicate contamination, long-tail collapse, overfitting noisy labels w 1
Diffusion Denoising diffusion probabilistic models Derive forward noising, reverse denoising, noise-prediction objective, score interpretation, DDPM/DDIM sampling, and schedule design Slow sampling, poor noise schedule, train-sample mismatch, oversmoothing, classifier-free guidance artifacts w 1
Diffusion Score matching and Langevin dynamics Connect denoising score matching to estimating ∇x log p(x), explain annealed Langevin dynamics, SDE formulation, and probability flow ODE Bad score estimates in low-density regions, unstable samplers, mode bias from incorrect step size w 1
Evaluation Metrics, validation, calibration, and benchmark design Choose metrics by objective: accuracy, F1, AUROC, AUPRC, NLL, ECE, BLEU/ROUGE, FID, CLIP score, human eval, pass@k, reward score Metric hacking, test leakage, benchmark saturation, poor confidence calibration w 1
Flow Matching Flow matching, rectified flows, and continuous normalizing flows Explain learning velocity fields, probability paths, ODE transport, simulation-free training, rectified flow straightening, and relation to diffusion Bad path choice, crossing trajectories, numerical solver error, poor likelihood/sample tradeoff w 1
Foundations Bias-variance tradeoff, double descent, and benign overfitting Go beyond textbook tradeoff: interpolation regime, overparameterization, implicit regularization, and why zero training error can still generalize Spurious memorization, unstable interpolation, data leakage mistaken for benign overfitting w 1
Foundations Generalization theory and inductive bias Discuss VC/Rademacher/PAC-style ideas conceptually, margins, norm-based bounds, compression, algorithmic stability, and why classical bounds often fail to explain deep learning Good train/test split but bad deployment, hidden distribution shift, overclaiming from weak bounds w 1
Generative Models Autoregressive generative models Explain exact likelihood factorization, teacher forcing, sampling temperature/top-k/top-p, exposure bias, and why AR models dominate discrete generation Slow sampling, compounding errors, mode repetition, likelihood/sampling-quality mismatch w 1
Generative Models GANs and adversarial training Explain minimax objective, discriminator-generator dynamics, Jensen-Shannon intuition, WGAN, gradient penalty, spectral norm, and mode collapse Discriminator overpowering, mode dropping, unstable oscillations, misleading loss curves w 1
Generative Models Normalizing flows and invertible models Understand change-of-variables formula, Jacobian determinant, coupling layers, autoregressive flows, CNFs, and exact likelihood modeling Expressivity bottlenecks, expensive Jacobians, likelihood high but samples bad, topology constraints w 1
Generative Models VAEs and latent-variable models Understand encoder/decoder, latent prior, reparameterization, ELBO tradeoff, beta-VAE, hierarchical VAEs, and likelihood vs perceptual quality Blurry reconstructions, posterior collapse, poor latent utilization, prior-posterior mismatch w 1
Neural Nets Backpropagation and automatic differentiation Explain reverse-mode AD, computation graphs, vector-Jacobian products, stop-gradient, detach, checkpointing, and gradient accumulation Accidental graph break, double backward memory explosion, incorrect detach, gradients all-reduced or scaled twice w 1
Optimization Gradient descent, SGD, momentum, Adam, AdamW, and optimizer dynamics Explain noise scale, adaptive preconditioning, weight decay vs L2 regularization, momentum buffers, sharp/flat minima, and large-batch behavior Adam generalization gap, wrong weight decay implementation, LR too high causing divergence, batch size changing effective dynamics w 1
Optimization Learning-rate schedules, warmup, clipping, and training stability Know cosine decay, linear warmup, gradient clipping, loss scaling, mixed precision, EMA, and how schedules interact with batch size and optimizer state Loss spikes, NaNs, undertraining from excessive warmup, clipping hiding bad gradients w 1
Optimization Second-order methods and curvature Understand Hessians, Fisher information, Gauss-Newton, natural gradient, K-FAC, sharpness, conditioning, and why full second-order methods are hard at scale Ill-conditioned loss surfaces, saddle points, curvature estimates too noisy, memory blowup w 1
Probability Bayesian ML and uncertainty estimation Understand priors, posteriors, posterior predictive distributions, epistemic vs aleatoric uncertainty, calibration, ensembles, MC dropout, Laplace approximation Overconfident OOD predictions, poor calibration, confusing variance types, prior dominating likelihood w 1
Probability ELBO, variational inference, and amortized inference Derive log p(x) lower bound, reconstruction term, KL regularizer, approximate posterior, reparameterization trick, and amortization gap Posterior collapse, loose bounds, bad variational family, KL vanishing or exploding w 1
Probability KL divergence, cross entropy, entropy, and maximum likelihood Explain KL as distribution mismatch, cross entropy as expected code length / NLL, MLE as minimizing empirical cross entropy, and why KL direction matters Mode collapse from forward/reverse KL mismatch, overconfident models, likelihood improving while samples worsen w 1
Regularization Explicit and implicit regularization Compare weight decay, dropout, augmentation, early stopping, label smoothing, mixup/cutmix, stochastic depth, and optimizer-induced regularization Underfitting from excessive regularization, calibration degradation, augmentation changing labels w 1
Research Debugging Failure analysis and experimental discipline Develop debugging habits: ablations, seed sweeps, sanity checks, loss decomposition, gradient/activation stats, data inspection, and controlled baselines Confounded experiments, unreproducible gains, silent preprocessing bugs, optimizing the wrong objective w 1
Robustness Distribution shift, OOD detection, adversarial examples, and robustness Explain covariate/label/concept shift, spurious correlations, adversarial perturbations, domain adaptation, and robust training High IID accuracy but deployment failure, shortcut learning, adversarial brittleness, bad OOD thresholds w 1
Scaling Scaling laws, data quality, compute optimality, and emergent behavior Discuss power-law scaling, Chinchilla-style tradeoffs, data/model/compute balance, phase transitions, and limits of benchmark-based claims Undertrained large models, overtrained small models, contaminated evals, mistaking memorization for emergence w 1
Self-Supervised Learning Contrastive learning and representation learning Explain InfoNCE, positive/negative pairs, mutual-information intuition, collapse prevention, BYOL/SimSiam-style non-contrastive learning, and representation probing Shortcut augmentations, false negatives, representation collapse, high linear-probe score but poor transfer w 1
Self-Supervised Learning Masked modeling and denoising objectives Compare masked language modeling, masked image modeling, denoising autoencoders, span corruption, and how corruption defines learned structure Too-easy corruption, mismatch between pretraining and downstream use, poor generative quality w 1
Sequence Modeling Tokenization, embeddings, language modeling, and autoregressive training Understand BPE/SentencePiece-style tokenization, next-token prediction, teacher forcing, exposure bias, perplexity, and sequence-level evaluation Tokenization artifacts, train-inference mismatch, low perplexity but poor generation, length bias w 1
Systems Distributed training, mixed precision, and memory efficiency Explain data/model/tensor/pipeline parallelism, ZeRO/FSDP, activation checkpointing, gradient accumulation, FP16/BF16/FP8, optimizer state memory Gradient desync, loss scaling bugs, communication bottlenecks, OOM from activations/KV cache w 1
Systems Inference optimization and deployment Understand batching, quantization, pruning, distillation, KV caching, speculative decoding, latency/throughput tradeoffs, and serving-time monitoring Quantization quality loss, tail latency spikes, cache fragmentation, train-serving skew w 1
25% of mix 30 topics
Actor-Critic GAE, TD(lambda), eligibility traces, and bias-variance control Derive GAE intuition; tune lambda/gamma for delayed rewards and long-horizon tasks Too-low lambda causing myopia; too-high lambda causing variance; value lag w 1
Actor-Critic Why Actor-Critic instead of pure critic / Q-learning Explain continuous action issues, policy expressivity, bootstrapped critic guidance, actor exploitation of critic errors, and critic-only limits Overestimated Q, critic hacking, actor chasing extrapolation error, unstable two-timescale learning w 1
Advanced RL Distributional RL and risk-sensitive objectives Focus on learning return distributions instead of means; connect to quantile regression, CVaR, robustness, and exploration Mean-value blindness, tail-risk failure, unstable distributional targets w 1
Estimation Monte Carlo estimators, importance sampling, rejection sampling, off-policy correction Emphasize likelihood ratios, support mismatch, self-normalization, effective sample size, and why RL ratios explode Ratio variance, missing support, stale policies, clipped estimators becoming biased w 1
Evaluation / Debugging RL training diagnostics, utilization metrics, and failure analysis Track reward, KL, entropy, clip fraction, advantage stats, response length, pass@1/pass@k, verifier accuracy, rollout latency, token throughput, KV utilization, GPU MFU/HFU Reward rises while eval falls, entropy collapse, KL spikes, length hacking, low rollout utilization, verifier overfit w 1
Exploration Train-time exploration vs test-time scaling / sampling Compare entropy bonuses, intrinsic rewards, Thompson/UCB-style ideas, pass@k, self-consistency, tree search, and inference compute Mode collapse, pass@1 improves while pass@k worsens, premature exploitation w 1
Foundations Bellman equations, contraction, bootstrapping, fixed points Focus on why Bellman backups work, when they are stable, and how approximation breaks guarantees Deadly triad: function approximation + bootstrapping + off-policy data w 1
Foundations Dynamic programming vs Monte Carlo vs temporal-difference learning Compare bias/variance, sample efficiency, and update locality; connect TD error to value learning High-variance MC, biased TD targets, bootstrapping from bad estimates w 1
Foundations MDP/POMDP formulation, horizon, discounting, observability Go beyond definitions: when the MDP assumption breaks, why partial observability changes credit assignment, how discount choice changes optimal behavior Reward delay, hidden state aliasing, nonstationary dynamics, wrong horizon choice w 1
LLM KL Control KL penalties, reference policies, cross entropy, MLE, and policy drift Explain forward vs reverse KL behavior, sampled KL estimators, reference resets, KL-free variants, and why implementation details matter Wrong KL estimator, double-counted KL, reference too stale, mode collapse vs mode covering w 1
LLM Policy Optimization GRPO, Dr.GRPO, DAPO, GSPO, CISPO, SAPO, DPPO, MaxRL, SimKO Compare objective unit: token, sequence, group, pass@k, clipped ratio, clipped IS weight, KL-regularized, critic-free; emphasize what instability each method tries to fix Entropy collapse, overlong responses, biased length incentives, MoE instability, pass@k degradation w 1
LLM RL Hyperparameters Group size, learning rate, PPO epochs, rollout length, generation length, temperature Focus on scaling rules and interactions: group variance, optimizer step size, rollout freshness, sequence length, clipping range, batch composition Zero-variance groups, stale old_logprobs, overtraining on same rollout, long-tail stragglers w 1
LLM RLVR RL with verifiable rewards and reasoning emergence Focus on math/code/verifier rewards, R1-style training, whether RL expands capability frontier or elicits latent skills, and base-model competence thresholds Memorized templates, shallow verifier exploitation, brittle reasoning transfer, false emergence w 1
Long-Horizon RL Prolonged RL, curricula, OPD, process supervision, and boundary expansion Study ProRL-style long training, reference resets, task diversity, on-policy distillation, teacher feedback on student rollouts, and dense token supervision Capability regression, teacher over-imitation, curriculum too easy/hard, sparse reward starvation w 1
Model-Based RL Model-based RL, planning, world models, MCTS, Dyna, MPC Compare learned dynamics vs model-free learning; when model error compounds; how planning and policy learning interact Model bias, hallucinated transitions, compounding rollout error, planner exploiting model bugs w 1
MoE RL MoE-specific RL, router behavior, train-inference mismatch, expert parallelism Focus on routing replay, expert load balance, sequence-level objectives, train/inference routing mismatch, and throughput bottlenecks Expert collapse, router instability, hot experts, poor batch invariance, inference mismatch w 1
Multi-Agent RL Multi-agent RL, self-play, opponent modeling, nonstationarity Focus on self-play curricula, Nash vs exploitability, cooperative credit assignment, and emergent behavior Policy cycling, nonstationary opponents, reward sharing ambiguity, collusion w 1
Off-policy RL Q-learning, DQN, SAC, TD3, CQL/IQL-style conservative critics Focus on off-policy reuse, target networks, double estimators, entropy regularization, and offline support constraints Extrapolation error, Q overestimation, distribution shift, dataset support holes w 1
Offline RL Offline RL, batch constraints, preference data, and dataset coverage Emphasize support mismatch, behavior cloning regularization, conservative objectives, and evaluation without environment access Out-of-distribution actions, high offline score / low online return, reward-model overfit w 1
Policy Optimization Advantage estimation, baselines, normalization, and whitening Connect A = Q − V to variance reduction; compare PPO advantages, GRPO group-relative advantages, standard deviation normalization, and baseline leakage Bad baseline bias, zero-variance groups, advantage scale drift, normalization hiding reward bugs w 1
Policy Optimization Policy gradient theorem and score-function estimators Derive log-prob trick, trajectory likelihood, causality trick, reward-to-go, and why gradients are noisy Credit assignment failure, sparse reward collapse, high variance, entropy collapse w 1
Rewards Reward design, shaping, sparse rewards, verifier rewards, and reward hacking Distinguish potential-based shaping, dense proxy rewards, learned reward models, verifiable rewards, and process rewards Specification gaming, proxy overoptimization, length reward hacks, verifier loopholes w 1
RLHF / Preference RL RLHF, reward modeling, DPO, IPO/KTO-style direct objectives Connect KL, cross entropy, MLE, Bradley-Terry preference models, implicit rewards in DPO, and when RLHF differs from supervised preference optimization Reward hacking, preference overfit, length bias, annotator bias, reference-policy dependence w 1
Safe RL Constrained RL, safe exploration, CMDPs, shielding, and robustness Discuss Lagrangian methods, hard constraints vs soft penalties, safety during exploration, and robust evaluation Constraint violation despite high reward, unsafe exploration, penalty tuning failure w 1
Systems / Async RL Asynchronous RL, partial rollouts, AReaL, slime, rollout bottlenecks, and staleness Compare sync vs async pipelines, policy lag, partial trajectory reuse, KV cache reuse limits, actor/learner separation, and stale logprob correction Policy staleness bias, replaying invalid KV caches, idle trainers, rollout-server bottlenecks w 1
Systems / Determinism Deterministic execution, batch invariance, atomic ops, numerical reproducibility Focus on non-associativity, kernel nondeterminism, dropout seeds, dynamic batching, atomic add, MoE routing, and reproducible evaluation Batch-dependent outputs, nondeterministic reductions, hidden seed drift, false regression signals w 1
Systems / Distributed Training Backpropagation in multi-node RL: Megatron, FSDP, ZeRO, TP/PP/DP/EP Explain gradient all-reduce/reduce-scatter, pipeline bubbles, sequence parallelism, expert parallelism, compute-communication overlap, and long-context training Multiple accidental all-reduces, silent loss scaling bugs, pipeline imbalance, communication dominating compute w 1
Systems / Memory Model copies and memory accounting in PPO/GRPO training Track policy, old policy, reference, reward/verifier, critic/value, optimizer states, gradients, activations, KV cache; compare ZeRO/FSDP/LoRA/checkpointing/offload Underestimated VRAM, duplicated weights, hidden optimizer state cost, activation blowup w 1
Systems / Rollouts Distributed inference, KV-cache transfer, continuous batching, vLLM vs SGLang Emphasize rollout throughput, prefill/decode split, PagedAttention, RadixAttention, prefix reuse, cache eviction, and GPU utilization measurement KV fragmentation, low cache hit rate, decode underutilization, scheduler unfairness, straggler batches w 1
Trust Regions PPO, TRPO, clipping, KL constraints, and trust-region logic Derive surrogate objectives; explain PPO min objective, ratio clipping, KL early stopping, TRPO natural gradient, and what happens without constraints Update explosion, policy collapse, clipping bias, stale rollout overuse, KL runaway w 1
25% of mix 30 topics
Controls PID, feedforward, cascaded control, and tuning Explain position/velocity/torque loops, anti-windup, derivative noise, saturation, and why feedforward improves tracking Integral windup, actuator saturation, oscillation, unstable gains, hidden latency w 1
Controls State-space control, LQR, MPC, and trajectory tracking Understand linearization, cost design, constraints, receding horizon control, terminal cost, and real-time feasibility Bad linearization, infeasible MPC, latency-induced instability, controller too slow for control rate w 1
Controls Whole-body control and operational-space control For humanoids/mobile manipulators: task hierarchies, nullspaces, constraints, contact consistency, and torque-level control Conflicting tasks, contact force infeasibility, nullspace instability, torque saturation w 1
Data / Sim Simulation, synthetic data, digital twins, domain randomization, and sim-to-real transfer Know MuJoCo, Isaac Sim, Gazebo, PyBullet-style tradeoffs; understand sensor simulation, contact modeling, randomization, and real-world validation Reality gap, bad contact model, over-randomization, policy exploits simulator, synthetic data bias w 1
Dynamics Rigid-body dynamics, Lagrangian/Newton-Euler methods, mass matrix, Coriolis, gravity terms Know what dynamics adds beyond kinematics; understand inverse dynamics, forward dynamics, contact forces, and model mismatch Controller assumes perfect model, ignored payload, unstable high-speed motion, bad gravity compensation w 1
Embodied AI Embodied reasoning, long-horizon task planning, tool use, and hierarchical policies Connect LLM/VLM planning with low-level skills; know task decomposition, skill libraries, affordance checking, and execution monitoring Planner produces impossible actions, no feedback loop, brittle task decomposition, compounding subtask errors w 1
Evaluation / Debugging Robot evaluation, benchmarking, failure analysis, and field deployment Track success rate, recovery rate, latency, control frequency, collision rate, intervention count, calibration drift, and long-tail failures Works in demo but not field, benchmark overfitting, unlogged failures, poor reproducibility, no safety envelope w 1
Kinematics Differential drive, Ackermann, holonomic, and legged robot kinematics Compare nonholonomic constraints, velocity mappings, wheel slip, body-frame vs world-frame commands, and odometry integration Wrong sign convention, impossible lateral motion command, wheel radius mismatch, encoder scale error w 1
Kinematics Forward and inverse kinematics for manipulators Derive link transforms, Jacobians, workspace limits, redundancy, singularities, and numerical IK with damping Singularity blowup, unreachable targets, joint-limit violation, IK choosing unsafe redundant posture w 1
Legged / Humanoid Legged locomotion, balance, gait generation, ZMP, centroidal dynamics, RL locomotion Know stability criteria, contact scheduling, terrain adaptation, recovery, and why learned locomotion is strong but brittle Falls from terrain shift, contact timing error, unstable sim-to-real transfer, actuator overheating w 1
Localization SLAM fundamentals: EKF-SLAM, graph SLAM, visual SLAM, LiDAR SLAM Understand landmarks, pose graphs, loop closure, bundle adjustment, scan matching, drift, and map consistency False loop closures, perceptual aliasing, map deformation, scale drift in monocular SLAM w 1
Manipulation Grasping, dexterous manipulation, force control, and contact-rich tasks Understand grasp synthesis, friction cones, compliance, tactile sensing, impedance control, and why contact makes manipulation hard Slipping grasps, contact instability, perception pose error, sim-to-real contact mismatch w 1
Math Foundations Rigid-body transformations, SE(2), SE(3), Lie groups, and coordinate frames Understand poses as transformations, frame composition, inverse transforms, exponential/log maps, adjoints, and why frame conventions dominate robotics bugs Wrong frame convention, left/right multiplication confusion, quaternion sign ambiguity, map/base/camera frame mismatch w 1
Math Foundations Rotation representations: Euler angles, quaternions, rotation matrices, axis-angle Explain singularities, interpolation, normalization, gimbal lock, quaternion double cover, and when each representation is appropriate Gimbal lock, non-normalized quaternion drift, wrong yaw extraction, discontinuous orientation loss w 1
Navigation Navigation stack, costmaps, local planners, obstacle avoidance, and recovery behavior Interview emphasis on practical autonomy: global planner vs local planner, inflation layers, dynamic obstacles, and behavior trees Robot freezes, oscillates near obstacles, unsafe inflation radius, recovery loop failure w 1
Perception 3D perception: point clouds, LiDAR, RGB-D, occupancy grids, TSDFs, NeRF/3DGS-style maps Compare explicit geometry, learned representations, map resolution, memory, real-time updates, and planning compatibility Noisy depth, dynamic objects corrupting map, occupancy inflation errors, map too slow for control loop w 1
Perception Object detection, segmentation, tracking, and pose estimation Understand 2D/3D detection, keypoints, ICP/PnP, tracking filters, data association, and uncertainty propagation ID switches, bad pose under occlusion, detector confidence miscalibration, perception-control latency w 1
Perception Visual geometry: cameras, calibration, epipolar geometry, depth, stereo, optical flow Know intrinsics/extrinsics, projection, triangulation, distortion, depth ambiguity, and calibration pipelines Poor calibration, rolling-shutter artifacts, bad depth at reflective/textureless surfaces, scale ambiguity w 1
Planning Graph search: BFS, Dijkstra, A*, D*, anytime and incremental planning Explain admissible heuristics, consistency, replanning, occupancy grids, costmaps, and why search still matters Non-admissible heuristic, stale costmap, local minima from inflated obstacles, planning too slowly w 1
Planning Sampling-based motion planning: PRM, RRT, RRT*, BIT*, kinodynamic planning Know probabilistic completeness, asymptotic optimality, collision checking, narrow passages, and dynamic constraints Path through infeasible dynamics, narrow-passage failure, slow collision checker, jerky trajectory w 1
Planning Trajectory optimization: CHOMP, STOMP, TrajOpt, direct collocation, iLQR/DDP Understand smoothness costs, constraints, gradients, initialization sensitivity, and optimizing in configuration vs task space Local minima, collision constraint violation, poor initialization, dynamically infeasible trajectory w 1
Robot Learning Diffusion policies, flow policies, action-token policies, and sequence prediction Compare continuous action denoising, action chunks, temporal ensembling, autoregressive action tokens, and latency-control tradeoffs Slow inference, over-smoothed actions, horizon mismatch, unstable closed-loop rollout w 1
Robot Learning Imitation learning, behavioral cloning, DAGGER, ACT, diffusion policies Focus on data quality, action chunking, compounding error, teleoperation data, closed-loop correction, and why BC is popular in real robots Covariate shift, blurry multimodal actions, poor recovery behavior, overfitting demonstrator quirks w 1
Robot Learning Reinforcement learning for robotics Understand sample efficiency, exploration safety, reward design, domain randomization, residual RL, and sim-first training Reward hacking, unsafe exploration, sim policy exploits physics bug, sparse reward failure w 1
State Estimation Bayes filters, Kalman filter, EKF, UKF, and particle filters Explain prediction/update, process vs measurement noise, observability, nonlinear filtering, covariance tuning, and delayed measurements Overconfident covariance, unobservable states, filter divergence, bad sensor timestamping w 1
State Estimation Sensor fusion: IMU, encoders, wheel odometry, GPS, LiDAR, Vicon, cameras Fuse complementary sensors; know bias, drift, extrinsics, synchronization, and when absolute vs relative measurements matter IMU bias drift, wrong extrinsics, timestamp skew, encoder slip, inconsistent frames w 1
Systems Hardware integration: actuators, encoders, IMUs, motor drivers, power, safety, and calibration Professional interviews often test debugging: wiring, signal levels, grounding, watchdogs, e-stops, calibration, thermal/current limits Brownouts, encoder sign flip, noisy power rail, missing fuse, motor saturation, unsafe failure mode w 1
Systems ROS2, middleware, real-time systems, and robot software architecture Understand nodes/topics/services/actions, QoS, TF, lifecycle nodes, executors, DDS, launch files, logging, bags, and timing Bad QoS, dropped messages, TF tree inconsistency, callback starvation, non-real-time control loop w 1
VLM / VLA Vision-language models for robotics perception and reasoning Learn how VLMs help with scene understanding, object grounding, instruction parsing, affordances, and high-level task decomposition Hallucinated objects, poor metric grounding, language ambiguity, no low-level controllability w 1
VLM / VLA Vision-language-action models: RT-2, RT-X, OpenVLA, π0-style policies, GR00T-style systems Understand end-to-end mapping from images/language/state to actions, cross-embodiment data, action tokenization vs continuous control, and adaptation via fine-tuning Distribution shift across robots, weak recovery, action space mismatch, catastrophic forgetting during fine-tuning w 1