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.
208 results across 1 active filter
Page 8 of 9
Prefers constructor injection for required dependencies while explaining the limited roles and costs of setter and field injection.
Chooses a query representation from static versus dynamic shape, portability, database features, readability, and performance evidence.
Chooses version-based conflict detection or database locks from contention, transaction duration, and invariant needs.
Uses HTTP rules for route-level policy and method security for reusable service operations without creating contradictory enforcement.
Chooses synchronous, reactive, or declarative clients based on the application's execution model while keeping shared timeout and error policy explicit.
Chooses credential transport and server state from client shape, revocation, browser threats, scaling, and operational requirements.
Chooses hooks by application readiness phase and keeps migrations, warm-up, listeners, and background resources owned and observable.
Uses profiles for named environment or deployment groups and focused conditions for feature or capability selection.
Chooses visibility, mutual exclusion, or atomic read-modify-write based on the invariant instead of treating the tools as interchangeable.
Chooses a focused MVC slice or full application context based on whether the risk is the web contract or complete wiring.
Positions records as transparent, shallowly immutable data carriers with generated value-oriented members and clear modeling limits.
Bases CSRF policy on whether browsers automatically attach credentials and keeps unsafe requests protected without disabling security globally.
Frames inheritance as a behavioral is-a relationship whose subtypes must remain valid substitutes, not merely a code-reuse shortcut.
Explains per-thread state, pooled-thread leakage, context cleanup, hidden dependencies, and virtual-thread scaling concerns.
Connects static ownership to constants and stateless operations while exposing the risks of global mutable state and initialization.
Overrides unstable external boundaries intentionally while keeping the framework behavior and real collaborators the test claims to prove.
Evaluates parallel streams through workload size, splittability, CPU cost, ordering, common-pool contention, state, and measurement.
Chooses concurrent collections by required atomic operations and iteration semantics rather than treating them as synchronized replacements.
Chooses Java time types by business meaning and handles time zones, daylight-saving transitions, persistence, and testable clocks.
Distinguishes reference identity from logical equality and shows how nulls, strings, enums, and domain values affect the choice.
Explains monitor wait sets and guarded loops while preferring queues, latches, semaphores, futures, and conditions for standard coordination.
Compares Java interfaces and abstract classes through contract, shared state, implementation reuse, and evolution trade-offs.
Compares Java list implementations using actual access patterns, traversal cost, memory locality, and insertion location.
Chooses an explicit lock only when timed, interruptible, conditional, or advanced acquisition behavior justifies manual lifecycle.