5 exercises on the adverbs that describe how code runs — asynchronously, concurrently, sequentially, lazily, and efficiently. Essential vocabulary for backend engineers, architects, and anyone who reads performance documentation.
Key verb–adverb patterns in this set
execute asynchronously — caller does not block; task runs in background
process concurrently — multiple operations in progress at the same time
run sequentially — one after another in a fixed order; required when steps depend on each other
cache aggressively / lazily — pre-load everything vs. populate on first request
batch efficiently — group many operations into one call to reduce overhead
0 / 5 completed
1 / 5
An API design document describes an endpoint behaviour:
"POST /reports/generate executes ___. The endpoint returns HTTP 202 Accepted immediately with a job ID. The caller must poll GET /reports/status/:id to check completion. Do not block the HTTP connection."
Which adverb describes task execution that does not block the caller?
Execute asynchronously means the task is initiated and the caller receives a response immediately — without waiting for the work to complete. The work happens in the background and the result is retrieved separately (polling, webhook, callback).
process asynchronously — background jobs: Sidekiq, Celery, BullMQ
run asynchronously — async/await in JavaScript/Python; Promise-based APIs
Contrast: execute synchronously = caller blocks until the task completes (HTTP 200 only after work is done). "Concurrently" means at the same time as other things — it describes parallelism, not the non-blocking caller interaction. "Sequentially" means one after another — the opposite of concurrent. The async/sync distinction is one of the most fundamental in distributed systems design.
2 / 5
A data pipeline architecture description states:
"The ETL stage processes records ___. We use a thread pool of 32 workers, each handling a separate batch of records simultaneously. This reduces total processing time from 4 hours to 12 minutes."
Which adverb describes multiple operations happening at the same time?
Process concurrently means multiple operations are in progress at the same time — using threads, goroutines, workers, or processes executing simultaneously.
Concurrency vocabulary in software engineering:
process concurrently — worker threads, goroutines (go func()), Python multiprocessing
execute concurrently — Promise.all() in JavaScript; asyncio.gather() in Python
run concurrently — parallel CI/CD pipeline steps: test and lint jobs running at the same time
Subtle distinction: concurrent means multiple tasks are in progress (may share CPU time); parallel means multiple tasks are literally executing simultaneously on separate cores. In practice, "concurrently" is used for both. "Asynchronously" focuses on the non-blocking interface, not the parallelism of execution. "Efficiently" is vague — it describes outcome, not mechanism. "Sequentially" is explicitly the opposite (one record at a time).
3 / 5
A database migration script comment reads:
"These migrations must be run ___. Migration 003 depends on the table created by Migration 002, which in turn requires Migration 001 to have completed. Running them out of order will cause a foreign key constraint error."
Which adverb means operations must happen one after another, in a fixed order?
Run sequentially means executing operations one at a time, in a defined order, where each step completes before the next begins.
This is the required execution model wherever ordering and dependency matter:
run sequentially — database migrations; ordered setup steps in test fixtures
execute sequentially — batch jobs where step N depends on step N-1 output
apply sequentially — Terraform plan output: "resources will be created sequentially"
The key phrase in the question is "depends on" — dependency chains require sequential execution. Contrast with run in parallel (which would cause the FK error described). "Atomically" means "as an indivisible unit" — all steps succeed or all are rolled back (database transaction semantics). "Asynchronously" means non-blocking — irrelevant to ordering. In CI pipelines, steps are configured as sequential or parallel using dependency declarations (needs: in GitHub Actions).
4 / 5
A performance engineering blog post compares two caching strategies:
"Strategy A: cache ___ — pre-load the cache on first request and keep it warm. Strategy B: cache ___ — populate the cache only when a key is actually requested, accepting a cold-start latency penalty."
Which pair of adverbs correctly fills Strategy A and Strategy B?
Cache aggressively / cache lazily is the canonical pair for these two caching strategies.
Cache aggressively: pre-populate the cache, cache everything that might be needed, optimise for read speed at the cost of memory:
CDN edge pre-warming; Redis cache-aside pre-load on startup
"We cache aggressively at the CDN layer to handle traffic spikes"
Cache lazily (lazy loading / lazy initialisation): only compute and store a value when it is first requested:
Hibernate lazy-loading of ORM associations; memoisation in functional programming
@cached_property in Python; lazy in Kotlin
Related pair: evaluate eagerly (compute now) vs. evaluate lazily (compute on demand). "Proactively / reactively" could work semantically but are not the technical terms used in caching literature. "Efficiently" and "selectively" are vague and not established caching vocabulary.
5 / 5
A backend engineer explains a performance optimisation in a PR description:
"Instead of sending one email per user as we process each event, we now collect events for 60 seconds and then send a single API call to the email service with up to 500 recipients at once. This reduces API calls from ~10,000/min to ~20/min."
Which adverb-verb collocation best describes this pattern?
Batch efficiently describes the pattern of grouping many individual operations into a single larger operation to reduce overhead — a classic performance optimisation for I/O-bound work.
Batching collocations in system design:
batch efficiently — collect N events, send one API call; amortise per-request overhead
batch writes — group database inserts: INSERT INTO ... VALUES (...), (...), (...) instead of N individual inserts
process in batches — ML inference: GPU processes 64 images at once (batch size 64)
The adverb "efficiently" emphasises that the batching achieves a measurable performance improvement (20x reduction in API calls in this example). "Process asynchronously" describes the caller model, not the grouping. "Queue lazily" would mean deferring work to a queue — related but doesn't capture the aggregation into a single call. "Send concurrently" means sending them in parallel — the opposite of what is described (one API call instead of many).