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 6 of 9
Explains visibility and ordering through synchronization actions instead of misleading main-memory and thread-cache folklore.
Defines mutable and immutable objects through observable state changes, aliasing, hashing, and API ownership.
Separates static annotations from runtime enforcement and explains how tools and frameworks can inspect type information.
Explains monitor mutual exclusion, visibility, reentrancy, lock identity, scope, and contention.
Explain the async state machine, continuation scheduling, and exception flow when a C# method awaits a Task.
Explains the path from Java source to bytecode and running code, including class loading and the JIT without turning the answer into JVM trivia.
Defines abstraction as a deliberate contract over essential behavior, then explains practical C# boundaries and the cost of weak abstractions.
Defines abstraction as a deliberate contract over essential behavior and keeps Java mechanisms secondary to the design purpose.
Explains Java lambdas as implementations of single-abstract-method contracts and connects standard interfaces to API design.
Explains callable decoration, closure-based configuration, metadata preservation, ordering, async behavior, and hidden control flow.
Defines Django as a batteries-included Python web framework and separates framework conveniences from application design.
Defines FastAPI as an ASGI web framework and explains how types drive validation, dependency resolution, responses, and OpenAPI.
Defines object-oriented programming clearly, then connects objects, responsibilities, and the main OOP mechanisms to practical C# design.
Defines OOP directly and connects Java objects, responsibilities, state, behavior, and collaboration to a practical design.
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.
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.
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 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.