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.
1345 results
Page 48 of 57
Explains making a fully constructed object visible through valid happens-before edges and final-field semantics.
Distinguishes a Java type definition from a concrete runtime instance and keeps identity, state, and polymorphism tied to the question.
Explains awaitable work, scheduled ownership, and eventual-result integration in asyncio.
Separates deployment-level Django configuration from cohesive application features and explains the app registry.
Compares explicit DRF serializers with model-derived serializer convenience and coupling.
Separates rapidly created short-lived objects from object graphs that remain reachable and chooses evidence and fixes accordingly.
Clarifies the difference between objects being retained accidentally and code simply allocating too much temporary memory.
Distinguishes sources that can produce iteration from stateful one-pass iterators and explains exhaustion and repeatability.
Contrasts opting out of static checking with safely accepting an unknown value that must be narrowed before use.
Compares copying strategies through nested state, ownership, performance, and domain identity rather than presenting deep copy as universally safer.
Separates overlapping I/O work from simultaneous execution across processing resources.
Separates proving an identity from deciding whether that identity may perform a specific action on a resource.
Distinguishes a type's natural order from external, reusable sort strategies and connects comparison consistency to sorted collections.
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.
Chooses Django database test isolation according to whether real commit and rollback behavior must be observed.
Separates SQL synchronization from transaction completion and explains recovery after database errors.
Contrasts blocking result retrieval with composable completion stages, explicit executors, failure handling, and limited cancellation guarantees.
Separates mandatory persistence-context identity from optional shared entity caching and its consistency tradeoffs.
Separates an unmodifiable API surface from a stable snapshot and from deep immutability of contained objects.
Separates propagation of entity operations from deletion of dependent children removed from an owning relationship.
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 full Spring MVC dispatch over mock Servlet objects from tests that cross an actual network and container boundary.