Skip to content

Tracks Drills Topics Technologies Tech stacks Skill areas

Tracks Drills Topics

Loading

Aporeon

Technical interview practice, from one developer to another.

About Support Privacy Terms Refund policy

Drills

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.

Search

Track

Practice style

Level

More filters1

Topic

Technology

Tech stack

Skill area

21 results across 1 active filter

Page 1 of 1

Concept questionMedium~10 min

Can asyncio code have race conditions even when one event loop uses one thread?

Shows how task interleaving across await points can violate a multi-step invariant.

Comparison questionHard~15 min

How do asyncio timeouts, wait_for(), and shield() affect cancellation?

Separates caller time bounds, cancellation propagation, and ownership of protected underlying work.

Python

Practice drill

Concept questionMedium~10 min

How does the Python asyncio event loop schedule tasks?

Builds a cooperative scheduling model for tasks, callbacks, readiness, and I/O polling.

Architecture scenarioHard~15 min

How do you choose between asyncio, threads, and processes in Python?

Chooses a concurrency model from workload, libraries, isolation, runtime build, and operational cost.

Debugging scenarioHard~15 min

How do you diagnose and fix blocking work on an asyncio event loop?

Finds synchronous I/O or CPU work that prevents the event loop from scheduling other tasks.

Debugging scenarioHard~15 min

How do you diagnose event-loop stalls, orphaned tasks, and async resource leaks?

Combines asyncio debug evidence, task inspection, warnings, profiling, and capacity signals.

Architecture scenarioHard~15 min

How do you handle exceptions and partial results from several asyncio tasks?

Defines fail-fast, all-results, and partial-success behavior for concurrent asyncio operations.

Architecture scenarioHard~15 min

How do you limit concurrent asyncio calls without creating unbounded work?

Places semaphore and admission boundaries around scarce work without retaining unlimited tasks.

Architecture scenarioHard~15 min

How should another thread interact with a running asyncio event loop?

Uses documented thread-safe scheduling APIs and keeps event-loop objects confined.

Architecture scenarioHard~15 min

How should asyncio code handle cancellation and cleanup?

Treats cancellation as cooperative control flow with reliable resource cleanup and propagation.

Architecture scenarioHard~15 min

How would you build a bounded producer-consumer pipeline with asyncio.Queue?

Designs backpressure, worker ownership, completion tracking, failure, and shutdown around asyncio queues.

Architecture scenarioHard~15 min

How would you shut down an asyncio service gracefully?

Coordinates admission stop, task cancellation or draining, resource closure, and bounded termination.

Debugging scenarioHard~15 min

What can break when Python work moves into a process pool?

Explains serialization, import safety, start methods, worker failure, and data-transfer cost.

Architecture scenarioHard~15 min

What can go wrong with fire-and-forget work created by asyncio.create_task()?

Explains task references, exceptions, caller lifetime, shutdown, and durable-work boundaries.

Concept questionHard~15 min

What does the GIL mean for Python concurrency now that free-threaded builds exist?

Explains conventional CPython thread execution and the optional free-threaded runtime boundary.

Comparison questionMedium~10 min

What is the difference between a coroutine, an asyncio Task, and a Future?

Explains awaitable work, scheduled ownership, and eventual-result integration in asyncio.

Concept questionEasy~5 min

What is the difference between asynchronous concurrency and parallelism in Python?

Separates overlapping I/O work from simultaneous execution across processing resources.

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.

Comparison questionMedium~10 min

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.