Drills

When should behavior or state be static rather than instance-based in Java?

Connects static ownership to constants and stateless operations while exposing the risks of global mutable state and initialization.

Concept questionMedium~10 min

When should Python async code use ContextVar instead of a global or thread-local value?

Uses task-aware context for tracing while keeping business inputs explicit and correctly reset.

When should Python code use secrets and compare_digest instead of random and normal equality?

Uses cryptographically secure token generation and timing-resistant comparison at credential boundaries.

Architecture scenarioMedium~7 min

When should you override a Spring bean with a mock in a test?

Overrides unstable external boundaries intentionally while keeping the framework behavior and real collaborators the test claims to prove.

JavaSpring Boot

Comparison questionHard~15 min

When should you use a Django signal instead of an explicit function call?

Uses Django signals selectively and makes transaction timing and side effects explicit.

When should you use Instant, LocalDateTime, or ZonedDateTime in Java?

Chooses Java time types by business meaning and handles time zones, daylight-saving transitions, persistence, and testable clocks.

Comparison questionEasy~5 min

When should you use pytest skip, xfail, or quarantine a test?

Distinguishes unavailable conditions, known defects, and unstable tests while keeping lost coverage visible.

pytestPython

When should you use == versus equals in Java?

Distinguishes reference identity from logical equality and shows how nulls, strings, enums, and domain values affect the choice.

When would you choose an interface or an abstract class in Java?

Compares Java interfaces and abstract classes through contract, shared state, implementation reuse, and evolution trade-offs.

When would you use a function-based or class-based Django view?

Chooses Django view style by clarity, reuse, and lifecycle needs rather than hierarchy preference.

Comparison questionHard~10 min

When would you use a Protocol instead of an abstract base class in Python?

Chooses structural or nominal contracts based on ownership, runtime identity, shared behavior, and third-party integration.

When would you use asyncio Lock, Event, Condition, or Semaphore?

Chooses task synchronization by protected state, notification predicates, and limited capacity.

Comparison questionHard~15 min

When would you use asyncio.TaskGroup or asyncio.gather()?

Compares structured task ownership with ordered result aggregation and different failure behavior.

Comparison questionHard~15 min

When would you use asyncio.to_thread() or run_in_executor()?

Compares convenient context-propagating thread offload with explicit executor selection and ownership.

When would you use Django select_related or prefetch_related?

Chooses Django relationship loading from relationship shape, result cardinality, and measured query behavior.

When would you use FastAPI TestClient versus an async HTTP client?

Chooses synchronous or asynchronous FastAPI test clients from the boundary exercised and resources involved.

FastAPIpytestPython

When would you use Spring application events instead of durable messaging?

Separates in-process decoupling from durable cross-process delivery and makes timing, failure, and transaction expectations explicit.

JavaSpring Boot

Architecture scenarioHard~10 min

When would you use SQLAlchemy ORM, SQLAlchemy Core, or raw SQL?

Chooses a SQLAlchemy abstraction from the work's shape instead of performance slogans.

PythonSQLAlchemy

Where should a Java service catch, translate, or rethrow exceptions?

Places exception handling at boundaries that can recover, add meaningful context, or translate abstraction levels while preserving the cause.

Architecture scenarioHard~15 min

Where should a SQLAlchemy transaction begin and end, and when are savepoints useful?

Aligns SQLAlchemy transactions with business operations and uses savepoints without inventing independent commits.

PythonSQLAlchemy

Architecture scenarioHard~15 min

Where should business logic live in a Django application?

Balances model methods, QuerySets, managers, and application services by the responsibility they own.

Architecture scenarioHard~10 min

Where should Python backend code catch, translate, or re-raise exceptions?

Places exception handling at meaningful boundaries and preserves causes, tracebacks, client contracts, and retry safety.