Pick a focused question that fits your time, stack, and interview goal.
How much time do you have?
Show one-drill sessions you can finish now.
1225 drills fit a 20-minute session. Closest fits first.
Page 47 of 52
Contrasts runtime-checked array covariance with compile-time-safe generic invariance and explains why generic arrays are restricted.
Treats raw types as a legacy compatibility boundary that can introduce heap pollution and delayed runtime failures.
Explains interference, stateful lambdas, execution-order assumptions, safe collection, and visibility of unavoidable effects.
Covers the Large Object Heap, big buffers, fragmentation pressure, and practical ways to avoid loading too much at once.
Diagnoses shared mutable function defaults and explains safe initialization without turning the behavior into a superstition.
Connects probabilistic decoding and changing service conditions to output variation, reproducibility limits, and appropriate testing.
Explains fail-fast iteration, safe removal patterns, structural modification, and why the exception is not a concurrency guarantee.
Explains how middleware order affects authentication, authorization, error handling, routing, CORS, and response behavior.
Uses development-only repeated rendering, Effects, and ref callbacks to expose impurity and missing cleanup.
Connects modern template blocks and stable list identity to DOM reuse, component state, and rendering correctness.
Uses guards for navigation UX while keeping permissions and data enforcement on the trusted server.
Explains how delegation preserves replaceable behavior and narrower coupling while recognizing valid inheritance cases.
Explains Java generic invariance through the unsafe write that subtype assignment would otherwise permit.
Separates String immutability from interning and connects both to safe sharing, equality, concatenation, and practical performance.
Connects Java's equality and hash contracts to real HashMap and HashSet behavior, including mutable-key failures.
Explains Java lambda capture through copied local values, mutable referenced objects, lifetime, and safe state handling.
Uses hierarchy and adjacency to recover context that flat chunks lose while avoiding indiscriminate document expansion.
Explains local filesystem limits, multiple instances, in-memory state, distributed cache, durable storage, and scale-out-safe API design.
Explains how generated text, markup, code, URLs, and tool arguments can become injection or integrity risks downstream.
Keeps JSON binding, validation, writable fields, and response evolution separate from domain and persistence models.
Explains how to choose an E2E flow, control test data, avoid brittleness, and cover frontend/API integration risk.
Chooses counters, traces, stack snapshots, GC dumps, full dumps, or a profiler from the production symptom and investigation cost.
Explains Aspire as a code-first application model and developer experience without confusing it with a production runtime or architecture style.
Separates hiding implementation complexity from controlling access to state, with practical examples where both ideas work together.