Differentiate blocking vs non-blocking I/O and discuss when to use each.

• A. Blocking waits for operation; non-blocking returns control and uses callbacks/promises; use blocking for simplicity, non-blocking for high concurrency.
• B. Blocking waits for operation and blocks the thread until completion; non-blocking is always faster in all scenarios.
• C. Non-blocking returns control and uses callbacks or promises; blocking can't be used with concurrency.
• D. Both approaches perform identically and have the same performance characteristics.

Answer: (D)

Blocking I/O holds onto the thread while the operation completes, so that thread can’t do other work during the wait. Non-blocking I/O returns control immediately, and you arrange to be notified when the operation finishes (through callbacks, promises/futures, or an event loop).

This difference changes how you design your code. Blocking I/O is simple and easy to reason about—your code reads like straightforward, sequential steps. That simplicity makes it a good choice for small programs or tasks where you don’t need to handle many tasks at once. Non-blocking I/O trades some simplicity for scalability: you can serve many I/O-bound tasks with fewer threads by letting the event loop drive completion callbacks or awaitable operations. But it comes with added complexity—managing partial reads/writes, maintaining state across callbacks, and ensuring correct flow without blocking.

Importantly, performance isn’t guaranteed to be the same. Blocking can be perfectly adequate or even faster for low-concurrency scenarios, while non-blocking shines when handling lots of concurrent connections or streams. The right choice depends on workload and architecture: use blocking when you want straightforward, easy-to-maintain code and concurrency isn’t a primary concern; use non-blocking for high-concurrency, I/O-bound workloads and when you’re building an event-driven or asynchronous system.