Asynchronous Programming in Python: A Practical Guide to asyncio


Asynchronous programming is one of Python's most useful tools for applications that spend time waiting on network requests, databases, message queues, and other I/O. It allows one thread to coordinate many overlapping operations without dedicating a separate thread to every request. Used well, it can improve throughput and responsiveness. Used carelessly, it can create hidden blocking, unbounded task growth, difficult cancellation bugs, and overloaded dependencies.
This guide explains the execution model behind async and await, shows how to coordinate concurrent work, and explores the engineering practices that make asynchronous applications reliable. It covers HTTP and database integrations, web frameworks, testing, backpressure, observability, and a practical project. The goal is not to make every Python function asynchronous; it is to choose the right execution model for the workload and manage its trade-offs deliberately.
Asynchronous programming in Python represents a paradigm shift in how developers approach concurrent execution and performance optimization. At its core, async Python allows your applications to handle multiple operations simultaneously without the overhead of traditional threading or multiprocessing. This approach has become increasingly critical as modern applications demand efficient handling of I/O-bound operations, network requests, and database queries. Understanding async Python is no longer optional for developers building scalable, high-performance applications—it's an essential skill that separates amateur code from production-ready systems.
To truly appreciate the power of async Python, we must first understand synchronous programming and its inherent limitations. In traditional synchronous code, each operation executes sequentially, one after another. When your program makes a network request, reads a file, or queries a database, the entire execution halts until that operation completes. This blocking behavior creates significant performance bottlenecks, especially in applications that perform numerous I/O operations. Imagine a web scraper that needs to fetch data from 100 different URLs—in synchronous code, each request must wait for the previous one to complete, resulting in cumulative wait times that can extend to several minutes.
The problems with blocking code become even more apparent in real-world scenarios. Consider a web application handling user requests: if each request involves database queries, API calls, or file operations, synchronous execution means your application can only serve one user at a time effectively. While one request waits for a database response, all other incoming requests queue up, leading to poor user experience and wasted server resources. Your CPU sits idle during these waiting periods, doing nothing productive while your application appears sluggish and unresponsive. This is where async Python shines—by allowing your program to switch between tasks during wait times, you maximize resource utilization and dramatically improve throughput.
A crucial distinction that often confuses developers new to async Python is the difference between concurrency and parallelism. Concurrency means managing multiple tasks at once, but not necessarily executing them simultaneously. Think of it as a single chef efficiently managing multiple pots on the stove—while one dish simmers, they prepare ingredients for another, creating the appearance of simultaneous work. Parallelism, on the other hand, involves true simultaneous execution across multiple processors, like having multiple chefs each preparing different dishes. Async Python provides concurrency through cooperative multitasking, making it ideal for I/O-bound operations where tasks spend most of their time waiting. For CPU-bound operations requiring genuine parallel processing, you'd still need multiprocessing or threading approaches. Understanding this distinction helps you choose the right tool for your specific performance challenges.
The async/await syntax in Python represents one of the most elegant solutions to concurrent programming ever designed. Introduced in Python 3.5, these keywords provide a clean, readable way to write asynchronous code that looks remarkably similar to traditional synchronous code. The async keyword defines a coroutine function—a special type of function that can pause its execution and yield control back to the event loop. When you prefix a function definition with async def, you're creating a coroutine that returns a coroutine object when called, rather than executing immediately. This fundamental change in behavior is what enables the non-blocking magic of asynchronous programming.
The await keyword is the counterpart to async and represents the points where your coroutine can pause execution. When you await an asynchronous operation, you're telling Python: 'This operation will take some time, so feel free to run other tasks while we wait for this to complete.' The beauty of await is that it makes asynchronous code read sequentially—you can write code that appears to execute line-by-line, but under the hood, the event loop orchestrates efficient concurrent execution. Here's a practical example: async def fetch\_data(url): response \= await http\_client.get(url); return response.json(). This function looks almost identical to synchronous code, but it won't block your entire application while waiting for the HTTP response.
Coroutines are the building blocks of async Python, and understanding their lifecycle is crucial for effective asynchronous programming. When you call a coroutine function, it doesn't execute immediately—instead, it returns a coroutine object that must be awaited or scheduled on an event loop. This lazy evaluation allows the event loop to coordinate multiple coroutines efficiently. Coroutines can await other coroutines, creating chains of asynchronous operations that the event loop manages seamlessly. For instance, you might have a coroutine that awaits multiple database queries, each of which is itself a coroutine. The event loop handles the complexity of scheduling and coordinating these nested operations, allowing you to focus on business logic rather than low-level concurrency management.
Practical implementation of async/await requires understanding several key patterns. First, remember that you can only use await inside async functions—attempting to await in synchronous code results in a syntax error. Second, any function that uses await must itself be defined as async, creating a chain of asynchronous code from your entry point down. Third, to actually run coroutines, you need an event loop—typically, you'll use asyncio.run() to execute your main coroutine, which handles event loop setup and teardown automatically. For example: import asyncio; async def main(): result \= await some\_async\_operation(); print(result); asyncio.run(main()). This pattern provides a clean entry point for asynchronous applications while handling all the event loop complexity behind the scenes.
Advanced async/await patterns unlock even greater power and flexibility. The asyncio.gather() function allows you to execute multiple coroutines concurrently and wait for all of them to complete, perfect for scenarios like fetching data from multiple APIs simultaneously. The asyncio.create\_task() function schedules a coroutine to run in the background, allowing your code to continue executing without waiting for completion—ideal for fire-and-forget operations. Context managers and iterators can also be asynchronous using async with and async for syntax, enabling clean resource management and iteration over asynchronous data streams. Mastering these patterns transforms async Python from a simple performance optimization into a comprehensive framework for building responsive, efficient applications that handle concurrent operations with grace and readability.
The event loop is the beating heart of async Python, the invisible orchestrator that makes concurrent execution possible. Think of the event loop as a traffic controller at a busy intersection—it monitors all ongoing operations, determines which tasks can progress, and efficiently switches between them to maximize throughput. When you write async Python code, the event loop continuously cycles through all pending coroutines, checking if any are ready to execute (typically because an I/O operation they were waiting for has completed), executing them until they hit the next await point, and then moving on to the next ready task. This cooperative multitasking model means your coroutines voluntarily yield control at await points, allowing the event loop to distribute execution time fairly across all concurrent operations.
The asyncio module is Python's standard library implementation for asynchronous programming, providing a comprehensive suite of tools for writing concurrent code. At its foundation, asyncio provides the event loop implementation itself, along with high-level APIs for running coroutines, scheduling callbacks, and managing asynchronous operations. The module has evolved significantly since its introduction, with Python 3.7+ offering simplified APIs like asyncio.run() that eliminate much of the boilerplate previously required. The asyncio library includes support for asynchronous networking with streams, subprocess management, synchronization primitives like locks and semaphores adapted for async code, and queue implementations for communication between coroutines—essentially, everything you need to build production-ready asynchronous applications.
Understanding how the event loop schedules and executes tasks reveals the performance benefits of async Python. When a coroutine awaits an I/O operation, it doesn't consume CPU resources while waiting—the event loop registers a callback for when that operation completes and immediately switches to another ready task. This means a single thread can efficiently handle hundreds or even thousands of concurrent I/O operations, as long as each operation spends time waiting rather than computing. The event loop maintains a queue of ready tasks and a registry of pending I/O operations monitored through system-level interfaces like select, poll, or epoll on Unix systems, or IOCP on Windows. When an I/O operation completes, the operating system notifies the event loop, which marks the corresponding task as ready and schedules it for execution.
The asyncio ecosystem extends far beyond the standard library, encompassing a rich collection of libraries designed for asynchronous operations. The aiohttp library provides async HTTP client and server functionality, enabling efficient web scraping and API consumption. The aiomysql, asyncpg, and motor libraries offer asynchronous database drivers for MySQL, PostgreSQL, and MongoDB respectively, eliminating database query bottlenecks. For Redis operations, aioredis provides async support, while aiofiles enables asynchronous file I/O. These libraries follow asyncio conventions, using coroutines and the await syntax to integrate seamlessly with your async code. When building async Python applications, leveraging these specialized libraries ensures your entire stack operates asynchronously, preventing synchronous bottlenecks that could negate the performance benefits of your async architecture.
Advanced event loop concepts unlock sophisticated concurrency patterns. The event loop supports callbacks scheduled with call\_soon(), call\_later(), and call\_at(), enabling precise timing control for periodic tasks. You can also run blocking code in a thread pool executor using run\_in\_executor(), preventing CPU-intensive operations from blocking the event loop. Signal handling, exception handling across coroutines, and graceful shutdown procedures all require understanding event loop mechanics. Custom event loop policies allow you to substitute alternative implementations or customize behavior for specific use cases. While most developers will use the default asyncio event loop successfully, understanding these mechanisms helps you diagnose performance issues, debug complex race conditions, and optimize your async Python applications for maximum efficiency and reliability.
FastAPI has revolutionized web development in Python by embracing async programming as a first-class feature, demonstrating the real-world power of async Python in production environments. This modern web framework leverages Python's async/await syntax to deliver performance comparable to Node.js and Go, making it ideal for building high-performance APIs and microservices. FastAPI async endpoints are defined using the same async def syntax you've learned, allowing your API routes to handle concurrent requests efficiently. When a request arrives at an async endpoint, FastAPI's underlying ASGI server (typically Uvicorn or Hypercorn) uses the event loop to handle multiple requests concurrently. While one request waits for a database query or external API call, the server processes other incoming requests, dramatically increasing throughput compared to traditional WSGI frameworks.
Implementing async endpoints in FastAPI is remarkably straightforward, yet the performance gains can be transformative. Consider a typical API endpoint that fetches user data from a database and enriches it with information from an external service: @app.get('/users/{user\_id}'); async def get\_user(user\_id: int): user \= await db.fetch\_user(user\_id); profile \= await external\_api.fetch\_profile(user\_id); return {\*\user, \\*profile}. This simple endpoint demonstrates the power of async Python—both the database query and API call execute concurrently with other requests, and if you fetch multiple pieces of data within a single request, you can use asyncio.gather() to parallelize those operations too. FastAPI handles request validation, serialization, and documentation generation automatically, allowing you to focus on business logic while the async architecture delivers exceptional performance.
Web scraping and data collection represent another domain where async Python excels, transforming operations that would take hours into tasks completing in minutes. Traditional synchronous web scrapers must wait for each HTTP request to complete before starting the next, creating massive inefficiencies when scraping hundreds or thousands of pages. An async scraper using aiohttp can send dozens or hundreds of concurrent requests, limited only by the target server's capacity and your network bandwidth. A typical implementation might look like: async def scrape\_urls(urls): async with aiohttp.ClientSession() as session: tasks \= \[fetch\_page(session, url) for url in urls\]; results \= await asyncio.gather(\*tasks); return results. This pattern scales beautifully—scraping 1000 URLs might take 30 seconds instead of 30 minutes, a 60x performance improvement that makes previously impractical projects suddenly viable.
Microservices architecture and distributed systems leverage async Python to build responsive, scalable services that communicate efficiently. In a microservices ecosystem, services constantly make network calls to other services, databases, and message queues. Async Python ensures these network operations don't create bottlenecks. A service might need to aggregate data from five different microservices to fulfill a single request—with async Python and asyncio.gather(), all five requests happen concurrently, reducing latency from the sum of all requests to merely the slowest single request. Message queue consumers benefit immensely from async processing, handling thousands of messages per second by processing them concurrently rather than sequentially. Projects using Kafka, RabbitMQ, or Redis Pub/Sub can implement async consumers that scale efficiently without the memory overhead of threading or multiprocessing.
Performance optimization in async Python requires understanding both what to optimize and what to measure. Profiling async code differs from synchronous code—traditional profilers may not accurately represent time spent waiting versus computing. Tools like py-spy and asyncio's debug mode help identify bottlenecks in async applications. Key optimization strategies include: batching operations to reduce overhead, using connection pooling to reuse database connections and HTTP sessions, implementing rate limiting and backpressure to prevent overwhelming downstream services, and choosing appropriate concurrency limits (too many concurrent tasks can actually decrease performance due to context switching). Memory usage deserves attention too—while async Python is more memory-efficient than threading for I/O-bound operations, creating thousands of tasks simultaneously can still consume significant memory. Monitoring tools like Prometheus combined with async-friendly metrics libraries help track performance in production, enabling data-driven optimization decisions that maximize the benefits of your async Python implementation.
Understanding when NOT to use async is just as important as knowing when to use it—applying async Python inappropriately can actually decrease performance and increase complexity. Async Python excels at I/O-bound operations where your code spends time waiting for external resources, but it provides no benefit for CPU-bound operations that require continuous computation. If your application performs heavy mathematical calculations, image processing, data encryption, or complex algorithms without waiting for external resources, async won't help and may hurt performance due to event loop overhead. For CPU-bound tasks, consider multiprocessing or specialized libraries like NumPy that release the GIL. Similarly, if your application is simple with minimal I/O operations, the added complexity of async code may not justify the negligible performance gains. Start with synchronous code for straightforward applications and introduce async only when profiling reveals I/O bottlenecks that would benefit from concurrent execution.
Blocking the event loop represents the most common and devastating mistake in async Python development. When you call a synchronous blocking operation within an async function without proper handling, you freeze the entire event loop, negating all benefits of async programming. Common culprits include: using the synchronous requests library instead of aiohttp, calling time.sleep() instead of asyncio.sleep(), performing file I/O with standard open() instead of aiofiles, or executing CPU-intensive operations directly in async functions. A single blocking call can bring your entire async application to a crawl, as all other coroutines wait for the blocking operation to complete. To prevent this, always use async-native libraries for I/O operations, and for unavoidable blocking code, use loop.run\_in\_executor() to execute it in a thread pool: await loop.run\_in\_executor(None, blocking\_function, args). This moves the blocking operation off the event loop thread, preserving concurrency for other tasks.
Proper exception handling in async code requires special attention, as exceptions in coroutines behave differently than in synchronous code. An exception in a coroutine that isn't awaited or gathered may go unnoticed, creating silent failures that are difficult to debug. When using asyncio.gather(), exceptions from any task will propagate to the gather() call, but you can use return\_exceptions=True to collect exceptions as results instead. For background tasks created with create\_task(), always store the task reference and await it or add a done callback to handle exceptions: task \= asyncio.create\_task(my\_coroutine()); task.add\_done\_callback(lambda t: handle\_exception(t.exception())). Context managers using async with ensure proper resource cleanup even when exceptions occur, making them preferable to manual try/finally blocks. Always wrap risky operations in try/except blocks within your coroutines, and consider implementing global exception handlers for the event loop to catch unexpected errors.
Resource management and connection pooling are critical for production async Python applications. Creating new database connections or HTTP sessions for each operation introduces significant overhead and can exhaust connection limits. Instead, establish connection pools at application startup and reuse them across operations. For aiohttp, create a single ClientSession per application: async with aiohttp.ClientSession() as session: \# reuse session for all requests. Database libraries like asyncpg have built-in connection pooling: pool \= await asyncpg.create\_pool(dsn); async with pool.acquire() as conn: \# use connection. Always use context managers (async with) to ensure proper resource cleanup. Be mindful of connection limits—if you have 100 concurrent tasks all trying to acquire database connections from a pool with only 10 connections, 90 tasks will wait. Configure pool sizes based on your application's concurrency needs and infrastructure limits. Implement retry logic with exponential backoff for transient failures, and consider circuit breakers for protecting against cascading failures in distributed systems.
Best practices for async Python development encompass code organization, testing, and architectural decisions. Structure your codebase to clearly separate async and sync code—mixing them carelessly leads to confusion and bugs. Prefer async all the way down: if you need async at any layer, make the entire call stack async to avoid awkward synchronous/asynchronous boundaries. Use type hints extensively (async def fetch\_data() \-\> dict:) to improve code clarity and catch errors early. For testing async code, pytest-asyncio provides async test fixtures and the ability to test coroutines directly: @pytest.mark.asyncio; async def test\_fetch\_data(): result \= await fetch\_data(); assert result\['status'\] \== 'ok'. Implement comprehensive logging that includes context about which task is executing, as traditional stack traces can be confusing in async code. Consider using structured logging libraries that handle async contexts properly. Document concurrency limits and rate limiting decisions in your code, as future maintainers need to understand the reasoning behind concurrency configurations. Finally, monitor your async applications in production with metrics specifically designed for async workloads: track event loop lag, pending task counts, and operation latencies to ensure your async Python implementation delivers the performance benefits you expect while maintaining reliability and maintainability.
An asynchronous database driver allows the event loop to run other tasks while a query is waiting on the database. That can improve throughput in an I/O-heavy API, but it does not make a slow query efficient. Index design, query plans, pagination, transaction duration, and connection-pool sizing remain essential. An async application can overwhelm a database more quickly if it launches too many concurrent queries.
Use a connection pool and calculate capacity across every application process and replica. If several replicas each open a large pool, the aggregate connection count can exceed the database's limit. Monitor pool wait time as well as query duration: a request may be slow because it is waiting for a connection rather than executing SQL.
Keep transactions short and explicit. Avoid holding a transaction open while calling a remote HTTP service or waiting for user input. Prefer to gather external information first, then perform a bounded database transaction that commits one coherent unit of work. With SQLAlchemy asyncio, use an AsyncSession per concurrent unit of work; do not share one session among unrelated tasks running concurrently. See the SQLAlchemy asyncio documentation for supported engines, drivers, and session patterns.
ASGI frameworks such as FastAPI and Starlette can run asynchronous request handlers. An async route is valuable when it awaits async dependencies such as an HTTP client, database driver, or message broker. A synchronous route can be appropriate when it calls blocking libraries and the framework delegates it to a thread pool. The key is to understand what each dependency does rather than assuming that async syntax is always faster.
Never call a blocking network client or database driver directly inside an async request handler. It can stall the event loop and delay unrelated requests. Replace it with an async client, isolate the blocking call with asyncio.to_thread when safe, or move the work to a dedicated worker.
Background tasks need a reliability decision. A task running inside a web process may disappear if the process restarts, and it shares CPU, memory, and connections with incoming requests. Best-effort notifications may be suitable for lightweight application-managed tasks. Important work that must survive restarts belongs in a durable queue or worker system with acknowledgements, retries, idempotency, and monitoring. Do not treat create_task as a complete job-processing platform.
For WebSockets and streaming responses, plan for disconnects, slow consumers, message-size limits, and bounded buffers. A client that reads slowly should not be able to consume unlimited memory or block a shared producer.
A real application may combine an async web server, a synchronous vendor SDK, CPU-intensive transformations, and legacy database code. The right design is to isolate execution-model boundaries rather than force every dependency into one style.
asyncio.to_thread runs a synchronous callable in a worker thread and lets the awaiting coroutine yield while it runs. It is useful for blocking I/O when the library is safe to call from a worker thread. It is not a universal solution for CPU-heavy Python code, and cancelling the awaiting task does not necessarily stop the underlying thread function immediately.
For CPU-bound work, consider a process pool or a separate worker service. Processes can use multiple CPU cores, but they introduce startup, serialization, and memory costs. Benchmark representative inputs before choosing. Avoid passing huge in-memory objects between processes when a file path, database identifier, or compact message would suffice.
Do not share thread-affine connections or clients across threads unless the library explicitly supports it. Also avoid calling asyncio.run inside a framework handler or library that is already running under an event loop. Let the application own the loop and expose awaitable functions to its callers.
Async tests should cover success and failure paths: timeouts, cancellation, retries, malformed responses, connection errors, and cleanup. pytest with pytest-asyncio is a common combination. Keep plugin configuration and fixture loop scopes consistent with the versions in use, and use async fixtures to close HTTP clients, database sessions, and application lifespans reliably.
Mock the boundary that performs external I/O rather than mocking the event loop. HTTPX provides transport-level testing options, and local test servers can exercise realistic request and response behavior. An async dependency must be replaced with an awaitable-compatible test double; a normal synchronous mock may conceal incorrect behavior.
Avoid arbitrary sleeps in concurrency tests. Use asyncio.Event, asyncio.Queue, or another explicit synchronization primitive to coordinate tasks. Test that a semaphore or worker pool actually enforces its configured limit. Test cancellation and verify that resources close even when a task exits unexpectedly.
Enable asyncio debug mode during development when diagnosing forgotten awaits, slow callbacks, and task lifecycle problems. Name important tasks, inspect unhandled task exceptions, and ensure that every task has an owner. Do not swallow CancelledError in a broad exception handler. Perform cleanup in finally blocks or async context managers, then allow cancellation to propagate unless suppression is intentional and documented.
More tasks do not automatically mean more throughput. Performance is constrained by downstream services, connection pools, CPU, memory, file descriptors, and API quotas. Increasing concurrency can help until a bottleneck is reached; beyond that point it can increase queueing, timeouts, and error rates.
Measure end-to-end latency percentiles, throughput, error rate, event-loop lag, active task count, queue depth, pool wait time, and downstream latency. Benchmark the same workload under realistic network conditions. A microbenchmark of coroutine creation says little about production performance.
Use asyncio.Semaphore to cap simultaneous operations. Use asyncio.Queue(maxsize=N) to apply backpressure between producers and consumers: when the queue is full, producers wait instead of consuming unlimited memory. A semaphore limits active work; a rate limiter controls how frequently new work starts. External APIs may require both.
Set separate budgets for dependencies with different capacities. A partner API with a strict quota should not share the same concurrency allowance as an internal cache. Bound response sizes, retry counts, queue lengths, and per-request execution time. Load-test bursts, slow dependencies, and partial failures rather than only the happy path.
Async code still requires ordinary security controls: validate untrusted input, use parameterized SQL, enforce authorization, protect secrets, and use TLS. Concurrency adds concerns around shared mutable state, duplicate work, and resource exhaustion. Limit tasks and connections per user or tenant where appropriate, and reject or shed work when the system is at capacity.
Retries can amplify outages. Retry only plausibly transient failures, use bounded exponential backoff with jitter, respect Retry-After, and retry writes only when they are safe to repeat. For operations such as payments or resource creation, use idempotency keys or a status lookup to resolve ambiguous timeouts.
Use structured logs and propagate trace or correlation identifiers across asynchronous boundaries. Useful metrics include request rate, latency percentiles, active tasks, queue depth, event-loop lag, connection-pool saturation, timeout counts, retry counts, and downstream dependency latency. Do not log credentials, access tokens, or sensitive request bodies.
Graceful shutdown should stop new work, allow in-flight operations a bounded period to finish, cancel or drain application-owned tasks, close clients and pools, and release queue consumers. Durable jobs should remain available to another worker rather than disappearing with the web process.
Build a command-line collector that retrieves records from a public API, validates responses, and writes normalized results to a JSON Lines file. Start with a synchronous implementation and record elapsed time, response status, and failures. Then implement an async version using one reusable HTTPX AsyncClient, explicit timeouts, connection limits, and a semaphore that caps concurrent requests.
Return a structured result for each input containing its identifier, status, elapsed time, parsed data, or error category. Add bounded retries for transient network failures, exponential backoff with jitter, and response validation. Do not retry validation errors or non-idempotent operations blindly. Stream completed records to disk so a large input does not need to remain in memory.
Test successful responses, non-success status codes, malformed JSON, timeouts, connection failures, retry exhaustion, and cancellation. Include a test that proves the concurrency limit is respected. Benchmark multiple input sizes and concurrency settings, reporting throughput, elapsed time, error rate, and memory use where practical. Explain that async helps when network waiting dominates, but excessive concurrency can trigger rate limits or degrade the remote service.
A strong portfolio version includes a README with setup instructions, configuration options, sample output, test commands, limitations, and benchmark methodology. Add structured logging, a dry-run mode, clear exit codes, and a safe way to rerun failed records. The project should demonstrate not only that you can use async and await, but that you understand resource limits and failure behavior.
Learn the foundations in order: Python functions and exceptions, context managers and resource cleanup, coroutines and awaitables, tasks and the event loop, then HTTP clients and bounded concurrency. Build a small collector before adding databases, queues, streaming, and production observability. Compare async with synchronous and threaded implementations so that you can explain the trade-offs rather than treating async as a universal performance upgrade.
Use official and maintained documentation as your reference:
The central principle is that asynchronous programming manages waiting efficiently; it does not remove the need for sound architecture. Reliable async systems give tasks clear owners, bound concurrency, propagate cancellation, manage resources carefully, and measure their behavior under realistic load.

Full-stack churn prediction platform using React, Django REST Framework, XGBoost, and SHAP. Enables telecom providers to identify at-risk customers, understand churn drivers, and support data-driven retention strategies.

Understand Apache Kafka architecture, KRaft, topics and partitions, producers, consumer groups, offsets, delivery guarantees, Kafka Connect, Kafka Streams, Python examples, and production best practices.
Read
Mastering SQL is the cornerstone of backend development excellence, empowering developers to build scalable, efficient, and data-driven applications that drive business success.
Read
Master the art of backend development and build scalable, secure server-side applications that power modern SaaS platforms
Read