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.
194 results across 1 active filter
Page 2 of 9
Implements duplicate suppression while preserving the first event for each idempotency key.
Distinguishes callable delegate values from publisher-controlled events and makes subscription lifetime explicit.
Explains how hash-based collections use hash codes and equality, then chooses Dictionary or HashSet from the value the program needs to store.
Distinguishes Django model saving, explicit model validation, form validation, and database constraints.
Uses controlled state transitions and intention-revealing APIs to keep objects valid rather than treating encapsulation as private fields alone.
Connects equality semantics to hash-based collections and chooses identity or value equality deliberately.
Preserves failure context, catches only where recovery or translation is possible, and uses filters without hiding unrelated faults.
Explain async/await as C# syntax over Task-based asynchronous work, with attention to non-blocking I/O and request throughput.
Explains static extension binding, instance-member precedence, namespace ambiguity, null receivers, and compatibility when APIs evolve.
Implements a stable first-unique-character search using counts and original order.
Flattens a tree into display paths while preserving order and preventing simple cycles.
Uses constraints to express required operations and explains safe assignment direction for generic producers and consumers.
Builds customer summaries from order rows using grouping, aggregation, and deterministic ordering.
Explains Python calls through object sharing, local parameter binding, mutation, reassignment, and explicit ownership.
Defines managed memory leaks as unwanted reachability and connects caches, listeners, class loaders, ThreadLocal values, and queues to retaining paths.
Focuses on ToList chains, collection capacity, repeated enumeration, and memory-aware data shaping.
Explains optimistic atomic updates, retries, contention, immutable state replacement, and the boundary of single-variable safety.
Explains Java's catch-or-declare rule and turns exception choice into a recoverability and API-contract decision rather than a universal slogan.
Explains attribute lookup, shared class state, instance shadowing, and automatic method binding through practical Python behavior.
Explains lexical scope, captured names, late lookup, loop callback failures, and deliberate state ownership in closures.
Explains collectors as terminal reduction strategies and composes grouping, mapping, counting, and summary operations.
Explains context-managed ownership, guaranteed exit behavior, exception suppression, and narrow resource lifetimes.
Explains how DRF turns an HTTP representation into request data and selects a response representation.
Explains stream sources, lazy intermediate operations, terminal execution, short-circuiting, encounter order, and single use.