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 7 of 9
Separates managing overlapping tasks from executing work simultaneously and connects both to Java backend design.
Separates view-oriented controller return handling from class-level response-body semantics without implying different request mapping.
Contrasts blocking result retrieval with composable completion stages, explicit executors, failure handling, and limited cancellation guarantees.
Separates an unmodifiable API surface from a stable snapshot and from deep immutability of contained objects.
Separates the persistence specification, its ORM implementation, and Spring's repository abstraction while keeping generated SQL visible.
Distinguishes one-to-one transformation from transformation plus flattening for nested collections, streams, and optionals.
Separates Spring's application framework and container from Boot's opinionated startup, dependency, configuration, and operational conventions.
Explains how Java compiles generic code and connects erasure to runtime checks, reflection limits, overloads, arrays, and bridge methods.
Explains heap, per-thread stacks, Metaspace, code cache, and native memory through the failures and evidence they produce.
Explains how GC roots retain reachable object graphs and turns heap evidence into a concrete ownership fix for static state, events, closures, queues, and caches.
Connects stable hashing and equality to dictionary and set correctness, including custom types and mutable-key failures.
Explains string immutability, concatenation behavior, and pragmatic use of StringBuilder in .NET.
Uses generics to preserve relationships among types and introduces bounds, constraints, and variance only where they clarify a real API.
Uses sealed types for deliberately closed variants and connects them to exhaustive reasoning, evolution, and open extension boundaries.
Uses bounds to express capabilities required by generic code and distinguishes them from wildcard flexibility at call sites.
Distinguishes deterministic cleanup from finalization and explains resource ownership in normal application code.
Chooses visibility, mutual exclusion, or atomic read-modify-write based on the invariant instead of treating the tools as interchangeable.
Chooses dataclasses for transparent data-oriented types while preserving invariants, safe defaults, and honest immutability claims.
Positions records as transparent, shallowly immutable data carriers with generated value-oriented members and clear modeling limits.
Explains asynchronous cleanup for resources whose shutdown path needs async work, such as flushing or closing remote connections.
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.
Chooses between synchronous and asynchronous FastAPI handlers based on the libraries and work they execute.
Connects static ownership to constants and stateless operations while exposing the risks of global mutable state and initialization.